refactor DHT for new service API
[oweals/gnunet.git] / src / cadet / gnunet-service-cadet_peer.c
index 50d40dce70d49683337072af3d98046ca69e6a2e..9fa25a1fa6e97b75fc955fcb3df55436ba6bb916 100644 (file)
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2013 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2013, 2015 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+     Boston, MA 02110-1301, USA.
 */
-
-
+/**
+ * @file cadet/gnunet-service-cadet_peer.c
+ * @brief GNUnet CADET service connection handling
+ * @author Bartlomiej Polot
+ */
 #include "platform.h"
 #include "gnunet_util_lib.h"
-
 #include "gnunet_signatures.h"
-
 #include "gnunet_transport_service.h"
+#include "gnunet_ats_service.h"
 #include "gnunet_core_service.h"
 #include "gnunet_statistics_service.h"
-
 #include "cadet_protocol.h"
-
 #include "gnunet-service-cadet_peer.h"
 #include "gnunet-service-cadet_dht.h"
 #include "gnunet-service-cadet_connection.h"
 /********************************   STRUCTS  **********************************/
 /******************************************************************************/
 
+
 /**
- * Struct containing info about a queued transmission to this peer
+ * Struct containing all information regarding a given peer
  */
-struct CadetPeerQueue
+struct CadetPeer
 {
-    /**
-      * DLL next
-      */
-  struct CadetPeerQueue *next;
+  /**
+   * ID of the peer
+   */
+  GNUNET_PEER_Id id;
 
-    /**
-      * DLL previous
-      */
-  struct CadetPeerQueue *prev;
+  /**
+   * Last time we heard from this peer
+   */
+  struct GNUNET_TIME_Absolute last_contact;
 
-    /**
-     * Peer this transmission is directed to.
-     */
-  struct CadetPeer *peer;
+  /**
+   * Paths to reach the peer, ordered by ascending hop count
+   */
+  struct CadetPeerPath *path_head;
 
-    /**
-     * Connection this message belongs to.
-     */
-  struct CadetConnection *c;
+  /**
+   * Paths to reach the peer, ordered by ascending hop count
+   */
+  struct CadetPeerPath *path_tail;
 
-    /**
-     * Is FWD in c?
-     */
-  int fwd;
+  /**
+   * Handle to stop the DHT search for paths to this peer
+   */
+  struct GCD_search_handle *search_h;
 
-    /**
-     * Pointer to info stucture used as cls.
-     */
-  void *cls;
+  /**
+   * Handle to stop the DHT search for paths to this peer
+   */
+  struct GNUNET_SCHEDULER_Task *search_delayed;
 
   /**
-   * Type of message
+   * Tunnel to this peer, if any.
    */
-  uint16_t type;
+  struct CadetTunnel *tunnel;
 
   /**
-   * Type of message
+   * Connections that go through this peer; indexed by tid.
    */
-  uint16_t payload_type;
+  struct GNUNET_CONTAINER_MultiHashMap *connections;
 
   /**
-   * Type of message
+   * Handle for core transmissions.
    */
-  uint32_t payload_id;
+  struct GNUNET_MQ_Handle *core_mq;
 
   /**
-     * Size of the message
-     */
-  size_t size;
+   * How many messages are in the queue to this peer.
+   */
+  unsigned int queue_n;
 
-    /**
-     * Set when this message starts waiting for CORE.
-     */
-  struct GNUNET_TIME_Absolute start_waiting;
+  /**
+   * Hello message.
+   */
+  struct GNUNET_HELLO_Message* hello;
 
-    /**
-     * Function to call on sending.
-     */
-  GCP_sent cont;
+  /**
+   * Handle to us offering the HELLO to the transport.
+   */
+  struct GNUNET_TRANSPORT_OfferHelloHandle *hello_offer;
+
+  /**
+   * Handle to our ATS request asking ATS to suggest an address
+   * to TRANSPORT for this peer (to establish a direct link).
+   */
+  struct GNUNET_ATS_ConnectivitySuggestHandle *connectivity_suggestion;
 
-    /**
-     * Closure for callback.
-     */
-  void *cont_cls;
 };
 
+
 /**
- * Struct containing all information regarding a given peer
+ * Information about a queued message on the peer level.
  */
-struct CadetPeer
-{
-    /**
-     * ID of the peer
-     */
-  GNUNET_PEER_Id id;
-
-    /**
-     * Axolotl permanent public key.
-     */
-  struct GNUNET_CRYPTO_EcdhePublicKey ax_key;
+struct CadetPeerQueue {
 
-    /**
-     * Last time we heard from this peer
-     */
-  struct GNUNET_TIME_Absolute last_contact;
-
-    /**
-     * Paths to reach the peer, ordered by ascending hop count
-     */
-  struct CadetPeerPath *path_head;
+  /**
+   * Envelope to cancel message before MQ sends it.
+   */
+  struct GNUNET_MQ_Envelope *env;
 
-    /**
-     * Paths to reach the peer, ordered by ascending hop count
-     */
-  struct CadetPeerPath *path_tail;
+  /**
+   * Peer (neighbor) this message is being sent to.
+   */
+  struct CadetPeer *peer;
 
-    /**
-     * Handle to stop the DHT search for paths to this peer
-     */
-  struct GCD_search_handle *search_h;
+  /**
+   * Continuation to call to notify higher layers about message sent.
+   */
+  GCP_sent cont;
 
   /**
-   * Handle to stop the DHT search for paths to this peer
+   * Closure for @a cont.
    */
-  struct GNUNET_SCHEDULER_Task *search_delayed;
+  void *cont_cls;
 
-    /**
-     * Tunnel to this peer, if any.
-     */
-  struct CadetTunnel *tunnel;
+  /**
+   * Time when message was queued for sending.
+   */
+  struct GNUNET_TIME_Absolute queue_timestamp;
 
-    /**
-     * Connections that go through this peer, indexed by tid;
-     */
-  struct GNUNET_CONTAINER_MultiHashMap *connections;
+  /**
+   * #GNUNET_YES if message was management traffic (POLL, ACK, ...).
+   */
+  int management_traffic;
 
-    /**
-     * Handle for queued transmissions
-     */
-  struct GNUNET_CORE_TransmitHandle *core_transmit;
+  /**
+   * Message type.
+   */
+  uint16_t type;
 
   /**
-   * Timestamp
+   * Message size.
    */
-  struct GNUNET_TIME_Absolute tmt_time;
+  uint16_t size;
 
   /**
-   * Transmission queue to core DLL head
+   * Type of the message's payload, if it was encrypted data.
    */
-  struct CadetPeerQueue *queue_head;
+  uint16_t payload_type;
 
   /**
-   * Transmission queue to core DLL tail
+   *ID of the payload (PID, ACK #, ...).
    */
-  struct CadetPeerQueue *queue_tail;
+  uint16_t payload_id;
 
   /**
-   * How many messages are in the queue to this peer.
+   * Connection this message was sent on.
    */
-  unsigned int queue_n;
+  struct CadetConnection *c;
 
   /**
-   * Hello message.
+   * Direction in @a c this message was send on (#GNUNET_YES = FWD).
    */
-  struct GNUNET_HELLO_Message* hello;
+  int c_fwd;
 };
 
 
@@ -217,7 +206,7 @@ extern struct GNUNET_PeerIdentity my_full_id;
 extern GNUNET_PEER_Id myid;
 
 /**
- * Peers known, indexed by PeerIdentity (CadetPeer).
+ * Peers known, indexed by PeerIdentity, values of type `struct CadetPeer`.
  */
 static struct GNUNET_CONTAINER_MultiPeerMap *peers;
 
@@ -232,101 +221,24 @@ static unsigned long long max_peers;
 static unsigned long long drop_percent;
 
 /**
- * Handle to communicate with core.
+ * Handle to communicate with CORE.
  */
 static struct GNUNET_CORE_Handle *core_handle;
 
 /**
- * Handle to try to start new connections.
+ * Our configuration;
  */
-static struct GNUNET_TRANSPORT_Handle *transport_handle;
-
-
-/******************************************************************************/
-/*****************************     DEBUG      *********************************/
-/******************************************************************************/
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 /**
- * Log all kinds of info about the queueing status of a peer.
- *
- * @param p Peer whose queue to show.
- * @param level Error level to use for logging.
+ * Handle to communicate with ATS.
  */
-static void
-queue_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level)
-{
-  struct CadetPeerQueue *q;
-  int do_log;
-
-  do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
-                                       "cadet-p2p",
-                                       __FILE__, __FUNCTION__, __LINE__);
-  if (0 == do_log)
-    return;
-
-  LOG2 (level, "QQQ Message queue towards %s\n", GCP_2s (p));
-  LOG2 (level, "QQQ  queue length: %u\n", p->queue_n);
-  LOG2 (level, "QQQ  core tmt rdy: %p\n", p->core_transmit);
-
-  for (q = p->queue_head; NULL != q; q = q->next)
-  {
-    LOG2 (level, "QQQ  - %s %s on %s\n",
-         GC_m2s (q->type), GC_f2s (q->fwd), GCC_2s (q->c));
-    LOG2 (level, "QQQ    payload %s, %u\n",
-         GC_m2s (q->payload_type), q->payload_id);
-    LOG2 (level, "QQQ    size: %u bytes\n", q->size);
-  }
-
-  LOG2 (level, "QQQ End queue towards %s\n", GCP_2s (p));
-}
-
+static struct GNUNET_ATS_ConnectivityHandle *ats_ch;
 
 /**
- * Log all kinds of info about a peer.
- *
- * @param peer Peer.
+ * Shutdown falg.
  */
-void
-GCP_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level)
-{
-  struct CadetPeerPath *path;
-  unsigned int conns;
-  int do_log;
-
-  do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
-                                       "cadet-p2p",
-                                       __FILE__, __FUNCTION__, __LINE__);
-  if (0 == do_log)
-    return;
-
-  if (NULL == p)
-  {
-    LOG2 (level, "PPP DEBUG PEER NULL\n");
-    return;
-  }
-
-  LOG2 (level, "PPP DEBUG PEER %s\n", GCP_2s (p));
-  LOG2 (level, "PPP last contact %s\n",
-       GNUNET_STRINGS_absolute_time_to_string (p->last_contact));
-  for (path = p->path_head; NULL != path; path = path->next)
-  {
-    char *s;
-
-    s = path_2s (path);
-    LOG2 (level, "PPP path: %s\n", s);
-    GNUNET_free (s);
-  }
-
-  LOG2 (level, "PPP core transmit handle %p\n", p->core_transmit);
-  LOG2 (level, "PPP DHT GET handle %p\n", p->search_h);
-  if (NULL != p->connections)
-    conns = GNUNET_CONTAINER_multihashmap_size (p->connections);
-  else
-    conns = 0;
-  LOG2 (level, "PPP # connections over link to peer: %u\n", conns);
-  queue_debug (p, level);
-  LOG2 (level, "PPP DEBUG END\n");
-}
+static int in_shutdown;
 
 
 /******************************************************************************/
@@ -338,7 +250,7 @@ GCP_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level)
  * Iterator to notify all connections of a broken link. Mark connections
  * to destroy after all traffic has been sent.
  *
- * @param cls Closure (peer disconnected).
+ * @param cls Closure (disconnected peer).
  * @param key Current key code (peer id).
  * @param value Value in the hash map (connection).
  *
@@ -352,10 +264,10 @@ notify_broken (void *cls,
   struct CadetPeer *peer = cls;
   struct CadetConnection *c = value;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "  notifying %s due to %s\n",
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Notifying %s due to %s disconnect\n",
        GCC_2s (c), GCP_2s (peer));
-  GCC_notify_broken (c, peer);
-
+  GCC_neighbor_disconnected (c, peer);
   return GNUNET_YES;
 }
 
@@ -364,7 +276,6 @@ notify_broken (void *cls,
  * Remove the direct path to the peer.
  *
  * @param peer Peer to remove the direct path from.
- *
  */
 static struct CadetPeerPath *
 pop_direct_path (struct CadetPeer *peer)
@@ -375,7 +286,9 @@ pop_direct_path (struct CadetPeer *peer)
   {
     if (2 >= iter->length)
     {
-      GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, iter);
+      GNUNET_CONTAINER_DLL_remove (peer->path_head,
+                                  peer->path_tail,
+                                  iter);
       return iter;
     }
   }
@@ -387,255 +300,402 @@ pop_direct_path (struct CadetPeer *peer)
 /***************************** CORE CALLBACKS *********************************/
 /******************************************************************************/
 
+
 /**
  * Method called whenever a given peer connects.
  *
- * @param cls closure
- * @param peer peer identity this notification is about
+ * @param cls Core closure (unused).
+ * @param peer Peer identity this notification is about
+ * @param mq Message Queue to this peer.
+ *
+ * @return Internal closure for handlers (CadetPeer struct).
  */
-static void
-core_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
+static void *
+core_connect_handler (void *cls,
+                      const struct GNUNET_PeerIdentity *peer,
+                      struct GNUNET_MQ_Handle *mq)
 {
-  struct CadetPeer *mp;
+  struct CadetPeer *neighbor;
   struct CadetPeerPath *path;
   char own_id[16];
 
-  strncpy (own_id, GNUNET_i2s (&my_full_id), 15);
-  mp = GCP_get (peer);
-  if (myid == mp->id)
+  GCC_check_connections ();
+  GNUNET_snprintf (own_id,
+                   sizeof (own_id),
+                   "%s",
+                   GNUNET_i2s (&my_full_id));
+
+  /* Save a path to the neighbor */
+  neighbor = GCP_get (peer, GNUNET_YES);
+  if (myid == neighbor->id)
   {
-    LOG (GNUNET_ERROR_TYPE_INFO, "CONNECTED %s (self)\n", own_id);
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "CONNECTED %s (self)\n",
+         own_id);
     path = path_new (1);
   }
   else
   {
-    LOG (GNUNET_ERROR_TYPE_INFO, "CONNECTED %s <= %s\n",
-         own_id, GNUNET_i2s (peer));
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "CONNECTED %s <= %s\n",
+         own_id,
+         GNUNET_i2s (peer));
     path = path_new (2);
-    path->peers[1] = mp->id;
-    GNUNET_PEER_change_rc (mp->id, 1);
-    GNUNET_STATISTICS_update (stats, "# peers", 1, GNUNET_NO);
+    path->peers[1] = neighbor->id;
+    GNUNET_PEER_change_rc (neighbor->id, 1);
+    GNUNET_assert (NULL == neighbor->core_mq);
+    neighbor->core_mq = mq;
   }
   path->peers[0] = myid;
   GNUNET_PEER_change_rc (myid, 1);
-  GCP_add_path (mp, path, GNUNET_YES);
+  GCP_add_path (neighbor, path, GNUNET_YES);
 
-  mp->connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
+  /* Create the connections hashmap */
+  GNUNET_assert (NULL == neighbor->connections);
+  neighbor->connections = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            "# peers",
+                            1,
+                            GNUNET_NO);
 
-  if (NULL != GCP_get_tunnel (mp) &&
-      0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, peer))
+  if ( (NULL != GCP_get_tunnel (neighbor)) &&
+       (0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, peer)) )
   {
-    GCP_connect (mp);
+    GCP_connect (neighbor);
   }
+  GCC_check_connections ();
 
-  return;
+  return neighbor;
 }
 
 
 /**
  * Method called whenever a peer disconnects.
  *
- * @param cls closure
- * @param peer peer identity this notification is about
+ * @param cls Core closure (unused).
+ * @param peer Peer identity this notification is about.
+ * @param internal_cls Internal closure (CadetPeer struct).
  */
 static void
-core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
+core_disconnect_handler (void *cls,
+                         const struct GNUNET_PeerIdentity *peer,
+                         void *internal_cls)
 {
-  struct CadetPeer *p;
+  struct CadetPeer *p = internal_cls;
   struct CadetPeerPath *direct_path;
   char own_id[16];
 
-  strncpy (own_id, GNUNET_i2s (&my_full_id), 15);
-  p = GNUNET_CONTAINER_multipeermap_get (peers, peer);
-  if (NULL == p)
+  GCC_check_connections ();
+  strncpy (own_id, GNUNET_i2s (&my_full_id), 16);
+  own_id[15] = '\0';
+  if (myid == p->id)
   {
-    GNUNET_break (0);
-    return;
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "DISCONNECTED %s (self)\n",
+         own_id);
   }
-  if (myid == p->id)
-    LOG (GNUNET_ERROR_TYPE_INFO, "DISCONNECTED %s (self)\n", own_id);
   else
-    LOG (GNUNET_ERROR_TYPE_INFO, "DISCONNECTED %s <= %s\n",
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "DISCONNECTED %s <= %s\n",
          own_id, GNUNET_i2s (peer));
+    p->core_mq = NULL;
+  }
   direct_path = pop_direct_path (p);
-  GNUNET_CONTAINER_multihashmap_iterate (p->connections, &notify_broken, p);
-  GNUNET_CONTAINER_multihashmap_destroy (p->connections);
-  p->connections = NULL;
-  if (NULL != p->core_transmit)
-    {
-      GNUNET_CORE_notify_transmit_ready_cancel (p->core_transmit);
-      p->core_transmit = NULL;
-      p->tmt_time.abs_value_us = 0;
-    }
-  GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO);
-
+  if (NULL != p->connections)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (p->connections,
+                                           &notify_broken,
+                                           p);
+    GNUNET_CONTAINER_multihashmap_destroy (p->connections);
+    p->connections = NULL;
+  }
+  GNUNET_STATISTICS_update (stats,
+                            "# peers",
+                            -1,
+                            GNUNET_NO);
   path_destroy (direct_path);
-  return;
+  GCC_check_connections ();
 }
 
 
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+
 /**
- * Functions to handle messages from core
- */
-static struct GNUNET_CORE_MessageHandler core_handlers[] = {
-  {&GCC_handle_create, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, 0},
-  {&GCC_handle_confirm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK,
-    sizeof (struct GNUNET_CADET_ConnectionACK)},
-  {&GCC_handle_broken, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
-    sizeof (struct GNUNET_CADET_ConnectionBroken)},
-  {&GCC_handle_destroy, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY,
-    sizeof (struct GNUNET_CADET_ConnectionDestroy)},
-  {&GCC_handle_ack, GNUNET_MESSAGE_TYPE_CADET_ACK,
-    sizeof (struct GNUNET_CADET_ACK)},
-  {&GCC_handle_poll, GNUNET_MESSAGE_TYPE_CADET_POLL,
-    sizeof (struct GNUNET_CADET_Poll)},
-  {&GCC_handle_kx, GNUNET_MESSAGE_TYPE_CADET_KX, 0},
-  {&GCC_handle_encrypted, GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED, 0},
-  {&GCC_handle_encrypted, GNUNET_MESSAGE_TYPE_CADET_AX, 0}
-};
+ * Check if the create_connection message has the appropriate size.
+ *
+ * @param cls Closure (unused).
+ * @param msg Message to check.
+ *
+ * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise.
+ */
+static int
+check_create (void *cls, const struct GNUNET_CADET_ConnectionCreate *msg)
+{
+  uint16_t size;
 
+  size = ntohs (msg->header.size);
+  if (size < sizeof (*msg))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
 
 /**
- * To be called on core init/fail.
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE
  *
- * @param cls Closure (config)
- * @param identity the public identity of this peer
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
  */
 static void
-core_init (void *cls,
-           const struct GNUNET_PeerIdentity *identity)
+handle_create (void *cls, const struct GNUNET_CADET_ConnectionCreate *msg)
 {
-  const struct GNUNET_CONFIGURATION_Handle *c = cls;
-  static int i = 0;
+  struct CadetPeer *peer = cls;
+  GCC_handle_create (peer, msg);
+}
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Core init\n");
-  if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id)))
-  {
-    LOG (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n"));
-    LOG (GNUNET_ERROR_TYPE_ERROR, " core id %s\n", GNUNET_i2s (identity));
-    LOG (GNUNET_ERROR_TYPE_ERROR, " my id %s\n", GNUNET_i2s (&my_full_id));
-    GNUNET_CORE_disconnect (core_handle);
-    core_handle = GNUNET_CORE_connect (c, /* Main configuration */
-                                       NULL,      /* Closure passed to CADET functions */
-                                       &core_init,        /* Call core_init once connected */
-                                       &core_connect,     /* Handle connects */
-                                       &core_disconnect,  /* remove peers on disconnects */
-                                       NULL,      /* Don't notify about all incoming messages */
-                                       GNUNET_NO, /* For header only in notification */
-                                       NULL,      /* Don't notify about all outbound messages */
-                                       GNUNET_NO, /* For header-only out notification */
-                                       core_handlers);    /* Register these handlers */
-    if (10 < i++)
-      GNUNET_assert (0);
-  }
-  GML_start ();
-  return;
+
+/**
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK
+ *
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
+ */
+static void
+handle_confirm (void *cls, const struct GNUNET_CADET_ConnectionACK *msg)
+{
+  struct CadetPeer *peer = cls;
+  GCC_handle_confirm (peer, msg);
 }
 
 
 /**
-  * Core callback to write a pre-constructed data packet to core buffer
-  *
-  * @param cls Closure (CadetTransmissionDescriptor with data in "data" member).
-  * @param size Number of bytes available in buf.
-  * @param buf Where the to write the message.
-  *
-  * @return number of bytes written to buf
-  */
-static size_t
-send_core_data_raw (void *cls, size_t size, void *buf)
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN
+ *
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
+ */
+static void
+handle_broken (void *cls, const struct GNUNET_CADET_ConnectionBroken *msg)
 {
-  struct GNUNET_MessageHeader *msg = cls;
-  size_t total_size;
+  struct CadetPeer *peer = cls;
+  GCC_handle_broken (peer, msg);
+}
 
-  GNUNET_assert (NULL != msg);
-  total_size = ntohs (msg->size);
 
-  if (total_size > size)
-  {
-    GNUNET_break (0);
-    return 0;
-  }
-  memcpy (buf, msg, total_size);
-  GNUNET_free (cls);
-  return total_size;
+/**
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY
+ *
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
+ */
+static void
+handle_destroy (void *cls, const struct GNUNET_CADET_ConnectionDestroy *msg)
+{
+  struct CadetPeer *peer = cls;
+  GCC_handle_destroy (peer, msg);
+}
+
+
+/**
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_ACK
+ *
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
+ */
+static void
+handle_ack (void *cls, const struct GNUNET_CADET_ACK *msg)
+{
+  struct CadetPeer *peer = cls;
+  GCC_handle_ack (peer, msg);
 }
 
 
 /**
- * Function to send a create connection message to a peer.
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_POLL
  *
- * @param c Connection to create.
- * @param size number of bytes available in buf
- * @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
  */
-static size_t
-send_core_connection_create (struct CadetConnection *c, size_t size, void *buf)
+static void
+handle_poll (void *cls, const struct GNUNET_CADET_Poll *msg)
 {
-  struct GNUNET_CADET_ConnectionCreate *msg;
-  struct GNUNET_PeerIdentity *peer_ptr;
-  const struct CadetPeerPath *p = GCC_get_path (c);
-  size_t size_needed;
-  int i;
+  struct CadetPeer *peer = cls;
+  GCC_handle_poll (peer, msg);
+}
 
-  if (NULL == p)
-    return 0;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION CREATE...\n");
-  size_needed =
-      sizeof (struct GNUNET_CADET_ConnectionCreate) +
-      p->length * sizeof (struct GNUNET_PeerIdentity);
+/**
+ * Check if the Key eXchange message has the appropriate size.
+ *
+ * @param cls Closure (unused).
+ * @param msg Message to check.
+ *
+ * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise.
+ */
+static int
+check_kx (void *cls, const struct GNUNET_CADET_KX *msg)
+{
+  uint16_t size;
+  uint16_t expected_size;
 
-  if (size < size_needed || NULL == buf)
+  size = ntohs (msg->header.size);
+  expected_size = sizeof (struct GNUNET_CADET_KX)
+                  + sizeof (struct GNUNET_MessageHeader);
+
+  if (size < expected_size)
   {
-    GNUNET_break (0);
-    return 0;
+    GNUNET_break_op (0);
+    return GNUNET_NO;
   }
-  msg = (struct GNUNET_CADET_ConnectionCreate *) buf;
-  msg->header.size = htons (size_needed);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE);
-  msg->cid = *GCC_get_id (c);
+  return GNUNET_YES;
+}
 
-  peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
-  for (i = 0; i < p->length; i++)
+/**
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_KX
+ *
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
+ */
+static void
+handle_kx (void *cls, const struct GNUNET_CADET_KX *msg)
+{
+  struct CadetPeer *peer = cls;
+  GCC_handle_kx (peer, msg);
+}
+
+
+/**
+ * Check if the encrypted message has the appropriate size.
+ *
+ * @param cls Closure (unused).
+ * @param msg Message to check.
+ *
+ * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise.
+ */
+static int
+check_encrypted (void *cls, const struct GNUNET_CADET_AX *msg)
+{
+  uint16_t size;
+  uint16_t minimum_size;
+
+  size = ntohs (msg->header.size);
+  minimum_size = sizeof (struct GNUNET_CADET_AX)
+                 + sizeof (struct GNUNET_MessageHeader);
+
+  if (size < minimum_size)
   {
-    GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
+    GNUNET_break_op (0);
+    return GNUNET_NO;
   }
+  return GNUNET_YES;
+}
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "CONNECTION CREATE (%u bytes long) sent!\n",
-       size_needed);
-  return size_needed;
+/**
+ * Handle for #GNUNET_MESSAGE_TYPE_CADET_AX (AXolotl encrypted traffic).
+ *
+ * @param cls Closure (CadetPeer for neighbor that sent the message).
+ * @param msg Message itself.
+ */
+static void
+handle_encrypted (void *cls, const struct GNUNET_CADET_AX *msg)
+{
+  struct CadetPeer *peer = cls;
+  GCC_handle_encrypted (peer, msg);
 }
 
 
 /**
- * Creates a path ack message in buf and frees all unused resources.
+ * To be called on core init/fail.
  *
- * @param c Connection to send an ACK on.
- * @param size number of bytes available in buf
- * @param buf where the callee should write the message
+ * @param cls Closure (config)
+ * @param identity The public identity of this peer.
+ */
+static void
+core_init_notify (void *cls,
+                  const struct GNUNET_PeerIdentity *identity);
+
+
+static void
+connect_to_core (const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  struct GNUNET_MQ_MessageHandler core_handlers[] = {
+    GNUNET_MQ_hd_var_size (create,
+                           GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE,
+                           struct GNUNET_CADET_ConnectionCreate,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (confirm,
+                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK,
+                             struct GNUNET_CADET_ConnectionACK,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (broken,
+                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
+                             struct GNUNET_CADET_ConnectionBroken,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (destroy,
+                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY,
+                             struct GNUNET_CADET_ConnectionDestroy,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (ack,
+                             GNUNET_MESSAGE_TYPE_CADET_ACK,
+                             struct GNUNET_CADET_ACK,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (poll,
+                             GNUNET_MESSAGE_TYPE_CADET_POLL,
+                             struct GNUNET_CADET_Poll,
+                             NULL),
+    GNUNET_MQ_hd_var_size (kx,
+                           GNUNET_MESSAGE_TYPE_CADET_KX,
+                           struct GNUNET_CADET_KX,
+                           NULL),
+    GNUNET_MQ_hd_var_size (encrypted,
+                           GNUNET_MESSAGE_TYPE_CADET_AX,
+                           struct GNUNET_CADET_AX,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+    core_handle = GNUNET_CORE_connecT (c, NULL,
+                                     &core_init_notify,
+                                     &core_connect_handler,
+                                     &core_disconnect_handler,
+                                     core_handlers);
+}
+
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+/******************************************************************************/
+
+/**
+ * To be called on core init/fail.
  *
- * @return number of bytes written to buf
+ * @param cls Closure (config)
+ * @param identity The public identity of this peer.
  */
-static size_t
-send_core_connection_ack (struct CadetConnection *c, size_t size, void *buf)
+static void
+core_init_notify (void *cls,
+                  const struct GNUNET_PeerIdentity *core_identity)
 {
-  struct GNUNET_CADET_ConnectionACK *msg = buf;
+  const struct GNUNET_CONFIGURATION_Handle *c = cls;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n");
-  if (sizeof (struct GNUNET_CADET_ConnectionACK) > size)
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Core init\n");
+  if (0 != memcmp (core_identity, &my_full_id, sizeof (my_full_id)))
   {
-    GNUNET_break (0);
-    return 0;
+    LOG (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n"));
+    LOG (GNUNET_ERROR_TYPE_ERROR, " core id %s\n", GNUNET_i2s (core_identity));
+    LOG (GNUNET_ERROR_TYPE_ERROR, " my id %s\n", GNUNET_i2s (&my_full_id));
+    GNUNET_CORE_disconnecT (core_handle);
+    connect_to_core (c);
+    return;
   }
-  msg->header.size = htons (sizeof (struct GNUNET_CADET_ConnectionACK));
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK);
-  msg->cid = *GCC_get_id (c);
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION ACK sent!\n");
-  return sizeof (struct GNUNET_CADET_ConnectionACK);
+  GML_start ();
 }
 
 
@@ -650,8 +710,11 @@ send_core_connection_ack (struct CadetConnection *c, size_t size, void *buf)
  * @param q Queued message
  *
  * @return CORE priority to use.
+ *
+ * FIXME make static
+ * FIXME use when sending
  */
-static enum GNUNET_CORE_Priority
+enum GNUNET_CORE_Priority
 get_priority (struct CadetPeerQueue *q)
 {
   enum GNUNET_CORE_Priority low;
@@ -664,7 +727,7 @@ get_priority (struct CadetPeerQueue *q)
   }
 
   /* Relayed traffic has lower priority, our own traffic has higher */
-  if (NULL == q->c || GNUNET_NO == GCC_is_origin (q->c, q->fwd))
+  if (NULL == q->c || GNUNET_NO == GCC_is_origin (q->c, q->c_fwd))
   {
     low = GNUNET_CORE_PRIO_BEST_EFFORT;
     high = GNUNET_CORE_PRIO_URGENT;
@@ -676,16 +739,76 @@ get_priority (struct CadetPeerQueue *q)
   }
 
   /* Bulky payload has lower priority, control traffic has higher. */
-  if (GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED == q->type
-      || GNUNET_MESSAGE_TYPE_CADET_AX == q->type)
+  if (GNUNET_MESSAGE_TYPE_CADET_AX == q->type)
     return low;
-  else
-    return high;
+  return high;
+}
+
+
+/**
+ * Destroy the peer_info and free any allocated resources linked to it
+ *
+ * @param peer The peer_info to destroy.
+ * @return #GNUNET_OK on success
+ */
+static int
+peer_destroy (struct CadetPeer *peer)
+{
+  struct GNUNET_PeerIdentity id;
+  struct CadetPeerPath *p;
+  struct CadetPeerPath *nextp;
+
+  GNUNET_PEER_resolve (peer->id, &id);
+  GNUNET_PEER_change_rc (peer->id, -1);
+
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "destroying peer %s\n",
+       GNUNET_i2s (&id));
+
+  if (GNUNET_YES !=
+      GNUNET_CONTAINER_multipeermap_remove (peers, &id, peer))
+  {
+    GNUNET_break (0);
+    LOG (GNUNET_ERROR_TYPE_WARNING, " peer not in peermap!!\n");
+  }
+  GCP_stop_search (peer);
+  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;
+  }
+  if (NULL != peer->tunnel)
+    GCT_destroy_empty (peer->tunnel);
+  if (NULL != peer->connections)
+  {
+    GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (peer->connections));
+    GNUNET_CONTAINER_multihashmap_destroy (peer->connections);
+    peer->connections = NULL;
+  }
+  if (NULL != peer->hello_offer)
+  {
+    GNUNET_TRANSPORT_offer_hello_cancel (peer->hello_offer);
+    peer->hello_offer = NULL;
+  }
+  if (NULL != peer->connectivity_suggestion)
+  {
+    GNUNET_ATS_connectivity_suggest_cancel (peer->connectivity_suggestion);
+    peer->connectivity_suggestion = NULL;
+  }
+
+  GNUNET_free_non_null (peer->hello);
+  GNUNET_free (peer);
+  return GNUNET_OK;
 }
 
 
 /**
- * Iterator over tunnel hash map entries to destroy the tunnel during shutdown.
+ * Iterator over peer hash map entries to destroy the peer during in_shutdown.
  *
  * @param cls closure
  * @param key current key code
@@ -694,33 +817,35 @@ get_priority (struct CadetPeerQueue *q)
  *         #GNUNET_NO if not.
  */
 static int
-shutdown_tunnel (void *cls,
-                 const struct GNUNET_PeerIdentity *key,
-                 void *value)
+shutdown_peer (void *cls,
+               const struct GNUNET_PeerIdentity *key,
+               void *value)
 {
   struct CadetPeer *p = value;
   struct CadetTunnel *t = p->tunnel;
 
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "  shutting down %s\n", GCP_2s (p));
   if (NULL != t)
     GCT_destroy (t);
+  p->tunnel = NULL;
+  peer_destroy (p);
   return GNUNET_YES;
 }
 
 
-
 /**
  * Check if peer is searching for a path (either active or delayed search).
  *
  * @param peer Peer to check
- *
- * @return GNUNET_YES if there is a search active.
- *         GNUNET_NO otherwise.
+ * @return #GNUNET_YES if there is a search active.
+ *         #GNUNET_NO otherwise.
  */
 static int
 is_searching (const struct CadetPeer *peer)
 {
-  return (NULL == peer->search_h && NULL == peer->search_delayed) ?
-         GNUNET_NO : GNUNET_YES;
+  return ( (NULL == peer->search_h) &&
+           (NULL == peer->search_delayed) ) ?
+    GNUNET_NO : GNUNET_YES;
 }
 
 
@@ -728,59 +853,16 @@ is_searching (const struct CadetPeer *peer)
  * @brief Start a search for a peer.
  *
  * @param cls Closure (Peer to search for).
- * @param tc Task context.
  */
 static void
-delayed_search (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+delayed_search (void *cls)
 {
   struct CadetPeer *peer = cls;
 
   peer->search_delayed = NULL;
-
-  if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
-    return;
-
+  GCC_check_connections ();
   GCP_start_search (peer);
-}
-
-
-/**
- * Destroy the peer_info and free any allocated resources linked to it
- *
- * @param peer The peer_info to destroy.
- *
- * @return GNUNET_OK on success
- */
-static int
-peer_destroy (struct CadetPeer *peer)
-{
-  struct GNUNET_PeerIdentity id;
-  struct CadetPeerPath *p;
-  struct CadetPeerPath *nextp;
-
-  GNUNET_PEER_resolve (peer->id, &id);
-  GNUNET_PEER_change_rc (peer->id, -1);
-
-  LOG (GNUNET_ERROR_TYPE_WARNING, "destroying peer %s\n", GNUNET_i2s (&id));
-
-  if (GNUNET_YES !=
-    GNUNET_CONTAINER_multipeermap_remove (peers, &id, peer))
-  {
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_WARNING, " not in peermap!!\n");
-  }
-  GCP_stop_search (peer);
-  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;
-  }
-  GCT_destroy_empty (peer->tunnel);
-  GNUNET_free (peer);
-  return GNUNET_OK;
+  GCC_check_connections ();
 }
 
 
@@ -788,7 +870,6 @@ peer_destroy (struct CadetPeer *peer)
  * Returns if peer is used (has a tunnel or is neighbor).
  *
  * @param peer Peer to check.
- *
  * @return #GNUNET_YES if peer is in use.
  */
 static int
@@ -886,7 +967,6 @@ peer_delete_oldest (void)
  * considering the tunnel properties.
  *
  * @param peer The destination peer.
- *
  * @return Best current known path towards the peer, if any.
  */
 static struct CadetPeerPath *
@@ -916,73 +996,13 @@ peer_get_best_path (const struct CadetPeer *peer)
 }
 
 
-/**
- * Is this queue element sendable?
- *
- * - All management traffic is always sendable.
- * - For payload traffic, check the connection flow control.
- *
- * @param q Queue element to inspect.
- *
- * @return #GNUNET_YES if it is sendable, #GNUNET_NO otherwise.
- */
-static int
-queue_is_sendable (struct CadetPeerQueue *q)
-{
-  /* Is PID-independent? */
-  switch (q->type)
-  {
-    case GNUNET_MESSAGE_TYPE_CADET_ACK:
-    case GNUNET_MESSAGE_TYPE_CADET_POLL:
-    case GNUNET_MESSAGE_TYPE_CADET_KX:
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
-      return GNUNET_YES;
-
-    case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
-    case GNUNET_MESSAGE_TYPE_CADET_AX:
-      break;
-
-    default:
-      GNUNET_break (0);
-  }
-
-  return GCC_is_sendable (q->c, q->fwd);
-}
-
-
-/**
- * Get first sendable message.
- *
- * @param peer The destination peer.
- *
- * @return First transmittable message, if any. Otherwise, NULL.
- */
-static struct CadetPeerQueue *
-peer_get_first_message (const struct CadetPeer *peer)
-{
-  struct CadetPeerQueue *q;
-
-  for (q = peer->queue_head; NULL != q; q = q->next)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Checking q:%p on c:%s\n", q, GCC_2s (q->c));
-    if (queue_is_sendable (q))
-      return q;
-  }
-
-  return NULL;
-}
-
-
 /**
  * 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.
  *
- * @param cls closure
- * @param path
+ * @param cls Closure (peer towards a path has been found).
+ * @param path Path created from the DHT query. Will be freed afterwards.
  */
 static void
 search_handler (void *cls, const struct CadetPeerPath *path)
@@ -990,6 +1010,7 @@ search_handler (void *cls, const struct CadetPeerPath *path)
   struct CadetPeer *peer = cls;
   unsigned int connection_count;
 
+  GCC_check_connections ();
   GCP_add_path_to_all (path, GNUNET_NO);
 
   /* Count connections */
@@ -997,234 +1018,52 @@ search_handler (void *cls, const struct CadetPeerPath *path)
 
   /* If we already have our minimum (or more) connections, it's enough */
   if (CONNECTIONS_PER_TUNNEL <= connection_count)
+  {
+    GCC_check_connections ();
     return;
+  }
 
   if (CADET_TUNNEL_SEARCHING == GCT_get_cstate (peer->tunnel))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n");
     GCP_connect (peer);
   }
-  return;
-}
-
-
-/**
- * Adjust core requested size to accomodate an ACK.
- *
- * @param message_size Requested size.
- *
- * @return Size enough to fit @c message_size and an ACK.
- */
-static size_t
-get_core_size (size_t message_size)
-{
-  return message_size + sizeof (struct GNUNET_CADET_ACK);
-}
-
-
-/**
- * Fill a core buffer with the appropriate data for the queued message.
- *
- * @param queue Queue element for the message.
- * @param buf Core buffer to fill.
- * @param size Size remaining in @c buf.
- * @param[out] pid In case its an encrypted payload, set payload.
- *
- * @return Bytes written to @c buf.
- */
-static size_t
-fill_buf (struct CadetPeerQueue *queue, void *buf, size_t size, uint32_t *pid)
-{
-  struct CadetConnection *c = queue->c;
-  size_t msg_size;
-
-  switch (queue->type)
-  {
-    case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
-      *pid = GCC_get_pid (queue->c, queue->fwd);
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "  otr payload ID %u\n", *pid);
-      msg_size = send_core_data_raw (queue->cls, size, buf);
-      ((struct GNUNET_CADET_Encrypted *) buf)->pid = htonl (*pid);
-      break;
-    case GNUNET_MESSAGE_TYPE_CADET_AX:
-      *pid = GCC_get_pid (queue->c, queue->fwd);
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "  ax payload ID %u\n", *pid);
-      msg_size = send_core_data_raw (queue->cls, size, buf);
-      ((struct GNUNET_CADET_AX *) buf)->pid = htonl (*pid);
-      break;
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
-    case GNUNET_MESSAGE_TYPE_CADET_KX:
-    case GNUNET_MESSAGE_TYPE_CADET_ACK:
-    case GNUNET_MESSAGE_TYPE_CADET_POLL:
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "  raw %s\n", GC_m2s (queue->type));
-      msg_size = send_core_data_raw (queue->cls, size, buf);
-      break;
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "  path create\n");
-      if (GCC_is_origin (c, GNUNET_YES))
-        msg_size = send_core_connection_create (c, size, buf);
-      else
-        msg_size = send_core_data_raw (queue->cls, size, buf);
-      break;
-    case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "  path ack\n");
-      if (GCC_is_origin (c, GNUNET_NO) ||
-          GCC_is_origin (c, GNUNET_YES))
-      {
-        msg_size = send_core_connection_ack (c, size, buf);
-      }
-      else
-      {
-        msg_size = send_core_data_raw (queue->cls, size, buf);
-      }
-      break;
-    case GNUNET_MESSAGE_TYPE_CADET_DATA:
-    case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE:
-    case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
-      /* This should be encapsulted */
-      msg_size = 0;
-      GNUNET_assert (0);
-      break;
-    default:
-      GNUNET_break (0);
-      LOG (GNUNET_ERROR_TYPE_WARNING, "  type unknown: %u\n", queue->type);
-      msg_size = 0;
-  }
-
-  GNUNET_assert (size >= msg_size);
-
-  return msg_size;
+  GCC_check_connections ();
 }
 
 
 /**
- * Core callback to write a queued packet to core buffer
- *
- * @param cls Closure (peer info).
- * @param size Number of bytes available in buf.
- * @param buf Where the to write the message.
- *
- * @return number of bytes written to buf
- */
-static size_t
-queue_send (void *cls, size_t size, void *buf)
-{
-  struct CadetPeer *peer = cls;
-  struct CadetConnection *c;
-  struct CadetPeerQueue *queue;
-  struct GNUNET_TIME_Relative core_wait_time;
-  const struct GNUNET_PeerIdentity *dst_id;
-  size_t msg_size;
-  size_t total_size;
-  size_t rest;
-  char *dst;
-  uint32_t pid;
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue send towards %s (max %u)\n",
-       GCP_2s (peer), size);
-
-  /* Sanity checking */
-  if (NULL == buf || 0 == size)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Buffer size 0.\n");
-    peer->tmt_time.abs_value_us = 0;
-    peer->core_transmit = NULL;
-    return 0;
-  }
-
-  /* Init */
-  rest = size;
-  total_size = 0;
-  dst = (char *) buf;
-  pid = 0;
-  peer->core_transmit = NULL;
-  queue = peer_get_first_message (peer);
-  if (NULL == queue)
-  {
-    GNUNET_break (0); /* Core tmt_rdy should've been canceled */
-    peer->tmt_time.abs_value_us = 0;
-    return 0;
-  }
-  core_wait_time = GNUNET_TIME_absolute_get_duration (peer->tmt_time);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, " core wait time %s\n",
-       GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_NO));
-  peer->tmt_time.abs_value_us = 0;
-
-  /* Copy all possible messages to the core buffer */
-  while (NULL != queue && rest >= queue->size)
-  {
-    c = queue->c;
-
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  on connection %s %s\n",
-         GCC_2s (c), GC_f2s(queue->fwd));
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  size %u ok (%u/%u)\n",
-         queue->size, total_size, size);
-
-    msg_size = fill_buf (queue, (void *) dst, size, &pid);
-
-    if (0 < drop_percent &&
-        GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on connection %s %s\n",
-           GC_m2s (queue->type), GC_m2s (queue->payload_type),
-           queue->payload_id, GCC_2s (c), GC_f2s (queue->fwd));
-      msg_size = 0;
-    }
-    else
-    {
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           "snd %s (%s %4u) on connection %s (%p) %s (size %u)\n",
-           GC_m2s (queue->type), GC_m2s (queue->payload_type),
-           queue->payload_id, GCC_2s (c), c, GC_f2s (queue->fwd), msg_size);
-    }
-    total_size += msg_size;
-    rest -= msg_size;
-    dst = &dst[msg_size];
-    msg_size = 0;
-
-    /* Free queue, but cls was freed by send_core_* in fill_buf. */
-    (void) GCP_queue_destroy (queue, GNUNET_NO, GNUNET_YES, pid);
-
-    /* Next! */
-    queue = peer_get_first_message (peer);
-  }
-
-  /* If more data in queue, send next */
-  if (NULL != queue)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  more data! (%u)\n", queue->size);
-    if (NULL == peer->core_transmit)
-    {
-      dst_id = GNUNET_PEER_resolve2 (peer->id);
-      peer->core_transmit =
-          GNUNET_CORE_notify_transmit_ready (core_handle,
-                                             GNUNET_NO, get_priority (queue),
-                                             GNUNET_TIME_UNIT_FOREVER_REL,
-                                             dst_id,
-                                             get_core_size (queue->size),
-                                             &queue_send,
-                                             peer);
-      peer->tmt_time = GNUNET_TIME_absolute_get ();
-      queue->start_waiting = GNUNET_TIME_absolute_get ();
-    }
-    else
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "*   tmt rdy called somewhere else\n");
-    }
-//     GCC_start_poll (); FIXME needed?
-  }
-  else
-  {
-//     GCC_stop_poll(); FIXME needed?
-  }
+ * Test if a message type is connection management traffic
+ * or regular payload traffic.
+ *
+ * @param type Message type.
+ *
+ * @return #GNUNET_YES if connection management, #GNUNET_NO otherwise.
+ */
+static int
+is_connection_management (uint16_t type)
+{
+  return type == GNUNET_MESSAGE_TYPE_CADET_ACK ||
+         type == GNUNET_MESSAGE_TYPE_CADET_POLL;
+}
+
+
+/**
+ * Debug function should NEVER return true in production code, useful to
+ * simulate losses for testcases.
+ *
+ * @return #GNUNET_YES or #GNUNET_NO with the decision to drop.
+ */
+static int
+should_I_drop (void)
+{
+  if (0 == drop_percent)
+    return GNUNET_NO;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "  return %d\n", total_size);
-  queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG);
+  if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
+    return GNUNET_YES;
 
-  return total_size;
+  return GNUNET_NO;
 }
 
 
@@ -1232,402 +1071,153 @@ queue_send (void *cls, size_t size, void *buf)
 /********************************    API    ***********************************/
 /******************************************************************************/
 
-
 /**
- * Free a transmission that was already queued with all resources
- * associated to the request.
- *
- * If connection was marked to be destroyed, and this was the last queued
- * message on it, the connection will be free'd as a result.
+ * Call the continuation after a message has been sent or dropped.
  *
- * @param queue Queue handler to cancel.
- * @param clear_cls Is it necessary to free associated cls?
- * @param sent Was it really sent? (Could have been canceled)
- * @param pid PID, if relevant (was sent and was a payload message).
- *
- * @return #GNUNET_YES if connection was destroyed as a result,
- *         #GNUNET_NO otherwise.
+ * @param q Queue handle.
+ * @param sent #GNUNET_YES if was sent to CORE, #GNUNET_NO if dropped.
  */
-int
-GCP_queue_destroy (struct CadetPeerQueue *queue, int clear_cls,
-                   int sent, uint32_t pid)
+static void
+call_peer_cont (const struct CadetPeerQueue *q, int sent)
 {
-  struct CadetPeer *peer;
-  int connection_destroyed;
-
-  peer = queue->peer;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "queue destroy %s\n", GC_m2s (queue->type));
-  if (GNUNET_YES == clear_cls)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, " free cls\n");
-    switch (queue->type)
-    {
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
-        LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n");
-        /* fall through */
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
-      case GNUNET_MESSAGE_TYPE_CADET_KX:
-      case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
-      case GNUNET_MESSAGE_TYPE_CADET_AX:
-      case GNUNET_MESSAGE_TYPE_CADET_ACK:
-      case GNUNET_MESSAGE_TYPE_CADET_POLL:
-        GNUNET_free_non_null (queue->cls);
-        break;
-
-      default:
-        GNUNET_break (0);
-        LOG (GNUNET_ERROR_TYPE_ERROR, " type %s unknown!\n",
-             GC_m2s (queue->type));
-    }
-  }
-  GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue);
-
-  if (queue->type != GNUNET_MESSAGE_TYPE_CADET_ACK &&
-      queue->type != GNUNET_MESSAGE_TYPE_CADET_POLL)
-  {
-    peer->queue_n--;
-  }
-
-  if (NULL != queue->cont)
+  LOG (GNUNET_ERROR_TYPE_DEBUG, " core mq just sent %s\n", GC_m2s (q->type));
+  if (NULL != q->cont)
   {
     struct GNUNET_TIME_Relative wait_time;
 
-    wait_time = GNUNET_TIME_absolute_get_duration (queue->start_waiting);
+    wait_time = GNUNET_TIME_absolute_get_duration (q->queue_timestamp);
     LOG (GNUNET_ERROR_TYPE_DEBUG, " calling callback, time elapsed %s\n",
          GNUNET_STRINGS_relative_time_to_string (wait_time, GNUNET_NO));
-    connection_destroyed = queue->cont (queue->cont_cls,
-                                        queue->c, sent, queue->type, pid,
-                                        queue->fwd, queue->size, wait_time);
-  }
-  else
-  {
-    connection_destroyed = GNUNET_NO;
+    q->cont (q->cont_cls,
+             q->c, q->c_fwd, sent,
+             q->type, q->payload_type, q->payload_id,
+             q->size, wait_time);
   }
+}
+
+
+/**
+ * Function called by MQ when a message is sent to CORE.
+ *
+ * @param cls Closure (queue handle).
+ */
+static void
+mq_sent (void *cls)
+{
+  struct CadetPeerQueue *q = cls;
 
-  if (NULL == peer_get_first_message (peer) && NULL != peer->core_transmit)
+  if (GNUNET_NO == q->management_traffic)
   {
-    GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
-    peer->core_transmit = NULL;
-    peer->tmt_time.abs_value_us = 0;
+    q->peer->queue_n--;
   }
-
-  GNUNET_free (queue);
-  return connection_destroyed;
+  call_peer_cont (q, GNUNET_YES);
+  GNUNET_free (q);
 }
 
 
 /**
- * @brief Queue and pass message to core when possible.
+ * @brief Send a message to another peer (using CORE).
  *
  * @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.
- * @param size Size of the message.
+ * @param message Message to send.
+ * @param payload_type Type of the message's payload, for debug messages.
+ *                     0 if the message is a retransmission (unknown payload).
+ *                     UINT16_MAX if the message does not have payload.
+ * @param payload_id ID of the payload (MID, ACK #, etc)
  * @param c Connection this message belongs to (can be NULL).
  * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!)
- * @param cont Continuation to be called once CORE has taken the message.
+ * @param cont Continuation to be called once CORE has sent the message.
  * @param cont_cls Closure for @c cont.
  *
- * @return Handle to cancel the message before it is sent. Once cont is called
- *         message has been sent and therefore the handle is no longer valid.
+ * @return A handle to the message in the queue or NULL (if dropped).
  */
 struct CadetPeerQueue *
-GCP_queue_add (struct CadetPeer *peer, void *cls, uint16_t type,
-               uint16_t payload_type, uint32_t payload_id, size_t size,
-               struct CadetConnection *c, int fwd,
-               GCP_sent cont, void *cont_cls)
+GCP_send (struct CadetPeer *peer,
+          const struct GNUNET_MessageHeader *message,
+          uint16_t payload_type,
+          uint32_t payload_id,
+          struct CadetConnection *c,
+          int fwd,
+          GCP_sent cont,
+          void *cont_cls)
 {
   struct CadetPeerQueue *q;
-  int error_level;
-  int priority;
-  int call_core;
+  uint16_t type;
+  uint16_t size;
 
-  if (NULL == c && GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN != type)
-    error_level = GNUNET_ERROR_TYPE_ERROR;
-  else
-    error_level = GNUNET_ERROR_TYPE_INFO;
-  LOG (error_level,
-       "que %s (%s %4u) on connection %s (%p) %s towards %s (size %u)\n",
+  GCC_check_connections ();
+  type = ntohs (message->type);
+  size = ntohs (message->size);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "que %s (%s %4u) on conn %s (%p) %s towards %s (size %u)\n",
        GC_m2s (type), GC_m2s (payload_type), payload_id,
        GCC_2s (c), c, GC_f2s (fwd), GCP_2s (peer), size);
 
-  if (error_level == GNUNET_ERROR_TYPE_ERROR)
-    GNUNET_assert (0);
   if (NULL == peer->connections)
   {
     /* We are not connected to this peer, ignore request. */
-    LOG (GNUNET_ERROR_TYPE_WARNING, "%s not a neighbor\n", GCP_2s (peer));
+    GNUNET_break (0);
+    LOG (GNUNET_ERROR_TYPE_INFO, "%s not a neighbor\n", GCP_2s (peer));
     GNUNET_STATISTICS_update (stats, "# messages dropped due to wrong hop", 1,
                               GNUNET_NO);
     return NULL;
   }
 
-  priority = 0;
-
-  if (GNUNET_MESSAGE_TYPE_CADET_POLL == type ||
-      GNUNET_MESSAGE_TYPE_CADET_ACK == type)
-  {
-    priority = 100;
-  }
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority);
-
-  call_core = (NULL == c || type == GNUNET_MESSAGE_TYPE_CADET_KX) ?
-               GNUNET_YES : GCC_is_sendable (c, fwd);
   q = GNUNET_new (struct CadetPeerQueue);
-  q->cls = cls;
+  q->env = GNUNET_MQ_msg_copy (message);
+  q->peer = peer;
+  q->cont = cont;
+  q->cont_cls = cont_cls;
+  q->queue_timestamp = GNUNET_TIME_absolute_get ();
+  q->management_traffic = is_connection_management (type);
   q->type = type;
+  q->size = size;
   q->payload_type = payload_type;
   q->payload_id = payload_id;
-  q->size = size;
-  q->peer = peer;
   q->c = c;
-  q->fwd = fwd;
-  q->cont = cont;
-  q->cont_cls = cont_cls;
-  if (100 > priority)
-  {
-    GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, q);
-    peer->queue_n++;
-  }
-  else
-  {
-    GNUNET_CONTAINER_DLL_insert (peer->queue_head, peer->queue_tail, q);
-    call_core = GNUNET_YES;
-  }
+  q->c_fwd = fwd;
+  GNUNET_MQ_notify_sent (q->env, mq_sent, q);
 
-  q->start_waiting = GNUNET_TIME_absolute_get ();
-  if (NULL == peer->core_transmit && GNUNET_YES == call_core)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "calling core tmt rdy towards %s for %u bytes\n",
-         GCP_2s (peer), size);
-    peer->core_transmit =
-        GNUNET_CORE_notify_transmit_ready (core_handle,
-                                           GNUNET_NO, get_priority (q),
-                                           GNUNET_TIME_UNIT_FOREVER_REL,
-                                           GNUNET_PEER_resolve2 (peer->id),
-                                           get_core_size (size),
-                                           &queue_send, peer);
-    peer->tmt_time = GNUNET_TIME_absolute_get ();
-  }
-  else if (GNUNET_NO == call_core)
+  if (GNUNET_YES == q->management_traffic)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s not needed\n",
-         GCP_2s (peer));
-
+    GNUNET_MQ_send (peer->core_mq, q->env);  // FIXME implement "_urgent", use
   }
   else
   {
-    struct GNUNET_TIME_Relative elapsed;
-    elapsed = GNUNET_TIME_absolute_get_duration (peer->tmt_time);
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s already called %s\n",
-         GCP_2s (peer),
-         GNUNET_STRINGS_relative_time_to_string (elapsed, GNUNET_NO));
-
-  }
-  queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG);
-  return q;
-}
-
-
-/**
- * Cancel all queued messages to a peer that belong to a certain connection.
- *
- * @param peer Peer towards whom to cancel.
- * @param c Connection whose queued messages to cancel. Might be destroyed by
- *          the sent continuation call.
- */
-void
-GCP_queue_cancel (struct CadetPeer *peer, struct CadetConnection *c)
-{
-  struct CadetPeerQueue *q;
-  struct CadetPeerQueue *next;
-  struct CadetPeerQueue *prev;
-  int connection_destroyed;
-
-  connection_destroyed = GNUNET_NO;
-  for (q = peer->queue_head; NULL != q; q = next)
-  {
-    prev = q->prev;
-    if (q->c == c)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "GMP queue cancel %s\n", GC_m2s (q->type));
-      GNUNET_break (GNUNET_NO == connection_destroyed);
-      if (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY == q->type)
-      {
-        q->c = NULL;
-      }
-      else
-      {
-        connection_destroyed = GCP_queue_destroy (q, GNUNET_YES, GNUNET_NO, 0);
-      }
-
-      /* Get next from prev, q->next might be already freed:
-       * queue destroy -> callback -> GCC_destroy -> cancel_queues -> here
-       */
-      if (NULL == prev)
-        next = peer->queue_head;
-      else
-        next = prev->next;
-    }
-    else
-    {
-      next = q->next;
-    }
-  }
-
-  if (NULL == peer->queue_head && NULL != peer->core_transmit)
-  {
-    GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
-    peer->core_transmit = NULL;
-    peer->tmt_time.abs_value_us = 0;
-  }
-}
-
-
-/**
- * Get the first transmittable message for a connection.
- *
- * @param peer Neighboring peer.
- * @param c Connection.
- *
- * @return First transmittable message.
- */
-static struct CadetPeerQueue *
-connection_get_first_message (struct CadetPeer *peer, struct CadetConnection *c)
-{
-  struct CadetPeerQueue *q;
-
-  for (q = peer->queue_head; NULL != q; q = q->next)
-  {
-    if (q->c != c)
-      continue;
-    if (queue_is_sendable (q))
+    if (GNUNET_YES == should_I_drop())
     {
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "  sendable!!\n");
-      return q;
+      LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n",
+           GC_m2s (q->type), GC_m2s (q->payload_type),
+           q->payload_id, GCC_2s (c), GC_f2s (q->c_fwd));
+      GNUNET_MQ_discard (q->env);
+      call_peer_cont (q, GNUNET_NO);
+      GNUNET_free (q);
+      return NULL;
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  not sendable\n");
+    GNUNET_MQ_send (peer->core_mq, q->env);
+    peer->queue_n++;
   }
 
-  return NULL;
+  GCC_check_connections ();
+  return q;
 }
 
 
 /**
- * Get the first message for a connection and unqueue it.
- *
- * Only tunnel (or higher) level messages are unqueued. Connection specific
- * messages are silently destroyed upon encounter.
- *
- * @param peer Neighboring peer.
- * @param c Connection.
- * @param destroyed[in/out] Was the connection destroyed (prev/as a result)?.
- *                          Can NOT be NULL.
- *
- * @return First message for this connection.
- */
-struct GNUNET_MessageHeader *
-GCP_connection_pop (struct CadetPeer *peer,
-                    struct CadetConnection *c,
-                    int *destroyed)
-{
-  struct CadetPeerQueue *q;
-  struct CadetPeerQueue *next;
-  struct GNUNET_MessageHeader *msg;
-  int dest;
-
-  GNUNET_assert (NULL != destroyed);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on connection %p\n", c);
-  for (q = peer->queue_head; NULL != q; q = next)
-  {
-    next = q->next;
-    if (q->c != c)
-      continue;
-    LOG (GNUNET_ERROR_TYPE_DEBUG, " - queued: %s (%s %u), cont: %p\n",
-         GC_m2s (q->type), GC_m2s (q->payload_type), q->payload_id,
-         q->cont);
-    switch (q->type)
-    {
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE:
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK:
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY:
-      case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN:
-      case GNUNET_MESSAGE_TYPE_CADET_ACK:
-      case GNUNET_MESSAGE_TYPE_CADET_POLL:
-        dest = GCP_queue_destroy (q, GNUNET_YES, GNUNET_NO, 0);
-        if (GNUNET_YES == dest)
-        {
-          GNUNET_break (GNUNET_NO == *destroyed);
-          *destroyed = GNUNET_YES;
-        }
-        continue;
-
-      case GNUNET_MESSAGE_TYPE_CADET_KX:
-      case GNUNET_MESSAGE_TYPE_CADET_ENCRYPTED:
-      case GNUNET_MESSAGE_TYPE_CADET_AX:
-      case GNUNET_MESSAGE_TYPE_CADET_AX_KX:
-        msg = (struct GNUNET_MessageHeader *) q->cls;
-        dest = GCP_queue_destroy (q, GNUNET_NO, GNUNET_NO, 0);
-        if (GNUNET_YES == dest)
-        {
-          GNUNET_break (GNUNET_NO == *destroyed);
-          *destroyed = GNUNET_YES;
-        }
-        return msg;
-
-      default:
-        GNUNET_break (0);
-        LOG (GNUNET_ERROR_TYPE_DEBUG, "Unknown message %s\n", GC_m2s (q->type));
-    }
-  }
-
-  return NULL;
-}
-
-/**
- * Unlock a possibly locked queue for a connection.
+ * Cancel sending a message. Message must have been sent with
+ * #GCP_send before.  May not be called after the notify sent
+ * callback has been called.
  *
- * If there is a message that can be sent on this connection, call core for it.
- * Otherwise (if core transmit is already called or there is no sendable
- * message) do nothing.
+ * It DOES call the continuation given to #GCP_send.
  *
- * @param peer Peer who keeps the queue.
- * @param c Connection whose messages to unlock.
+ * @param q Queue handle to cancel
  */
 void
-GCP_queue_unlock (struct CadetPeer *peer, struct CadetConnection *c)
+GCP_send_cancel (struct CadetPeerQueue *q)
 {
-  struct CadetPeerQueue *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, get_priority (q),
-                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                         GNUNET_PEER_resolve2 (peer->id),
-                                         get_core_size (size),
-                                         &queue_send,
-                                         peer);
-  peer->tmt_time = GNUNET_TIME_absolute_get ();
+  call_peer_cont (q, GNUNET_NO);
+  GNUNET_MQ_send_cancel (q->env);
+  GNUNET_free (q);
 }
 
 
@@ -1639,7 +1229,10 @@ GCP_queue_unlock (struct CadetPeer *peer, struct CadetConnection *c)
 void
 GCP_init (const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
+  cfg = c;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "GCP_init\n");
+  in_shutdown = GNUNET_NO;
   peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_PEERS",
@@ -1664,42 +1257,13 @@ GCP_init (const struct GNUNET_CONFIGURATION_Handle *c)
     LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
     LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
   }
-
-  core_handle = GNUNET_CORE_connect (c, /* Main configuration */
-                                     NULL,      /* Closure passed to CADET functions */
-                                     &core_init,        /* Call core_init once connected */
-                                     &core_connect,     /* Handle connects */
-                                     &core_disconnect,  /* remove peers on disconnects */
-                                     NULL,      /* Don't notify about all incoming messages */
-                                     GNUNET_NO, /* For header only in notification */
-                                     NULL,      /* Don't notify about all outbound messages */
-                                     GNUNET_NO, /* For header-only out notification */
-                                     core_handlers);    /* Register these handlers */
-  if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_get_value_yesno (c, "CADET", "DISABLE_TRY_CONNECT"))
-  {
-    transport_handle = GNUNET_TRANSPORT_connect (c, &my_full_id, NULL, /* cls */
-                                                 /* Notify callbacks */
-                                                 NULL, NULL, NULL);
-  }
-  else
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
-    LOG (GNUNET_ERROR_TYPE_WARNING, "*  DISABLE TRYING CONNECT in config  *\n");
-    LOG (GNUNET_ERROR_TYPE_WARNING, "*  Use this only for test purposes.  *\n");
-    LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
-    transport_handle = NULL;
-  }
-
-
-
+  ats_ch = GNUNET_ATS_connectivity_init (c);
+  connect_to_core (c);
   if (NULL == core_handle)
   {
     GNUNET_break (0);
     GNUNET_SCHEDULER_shutdown ();
-    return;
   }
-
 }
 
 
@@ -1709,32 +1273,44 @@ GCP_init (const struct GNUNET_CONFIGURATION_Handle *c)
 void
 GCP_shutdown (void)
 {
-  GNUNET_CONTAINER_multipeermap_iterate (peers, &shutdown_tunnel, NULL);
-
-  if (core_handle != NULL)
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down peer subsystem\n");
+  in_shutdown = GNUNET_YES;
+  if (NULL != core_handle)
   {
-    GNUNET_CORE_disconnect (core_handle);
-    core_handle = NULL;
+    GNUNET_CORE_disconnecT (core_handle);
+        core_handle = NULL;
   }
-  if (transport_handle != NULL)
+  GNUNET_PEER_change_rc (myid, -1);
+  /* With MQ API, CORE calls the disconnect handler for every peer
+   * after calling GNUNET_CORE_disconnecT, shutdown must occur *after* that.
+   */
+  GNUNET_CONTAINER_multipeermap_iterate (peers,
+                                         &shutdown_peer,
+                                         NULL);
+  if (NULL != ats_ch)
   {
-    GNUNET_TRANSPORT_disconnect (transport_handle);
-    transport_handle = NULL;
+    GNUNET_ATS_connectivity_done (ats_ch);
+    ats_ch = NULL;
   }
-  GNUNET_PEER_change_rc (myid, -1);
+  GNUNET_CONTAINER_multipeermap_destroy (peers);
+  peers = NULL;
 }
 
 
 /**
- * Retrieve the CadetPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Retrieve the CadetPeer stucture associated with the peer. Optionally create
+ * one and insert it in the appropriate structures if the peer is not known yet.
  *
  * @param peer_id Full identity of the peer.
+ * @param create #GNUNET_YES if a new peer should be created if unknown.
+ *               #GNUNET_NO otherwise.
  *
  * @return Existing or newly created peer structure.
+ *         NULL if unknown and not requested @a create
  */
 struct CadetPeer *
-GCP_get (const struct GNUNET_PeerIdentity *peer_id)
+GCP_get (const struct GNUNET_PeerIdentity *peer_id, int create)
 {
   struct CadetPeer *peer;
 
@@ -1746,9 +1322,12 @@ GCP_get (const struct GNUNET_PeerIdentity *peer_id)
     {
       peer_delete_oldest ();
     }
-        GNUNET_CONTAINER_multipeermap_put (peers, peer_id, peer,
-                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-        peer->id = GNUNET_PEER_intern (peer_id);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (peers,
+                                                      peer_id,
+                                                      peer,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    peer->id = GNUNET_PEER_intern (peer_id);
   }
   peer->last_contact = GNUNET_TIME_absolute_get ();
 
@@ -1757,36 +1336,36 @@ GCP_get (const struct GNUNET_PeerIdentity *peer_id)
 
 
 /**
- * Retrieve the CadetPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Retrieve the CadetPeer stucture associated with the
+ * peer. Optionally create one and insert it in the appropriate
+ * structures if the peer is not known yet.
  *
  * @param peer Short identity of the peer.
+ * @param create #GNUNET_YES if a new peer should be created if unknown.
+ *               #GNUNET_NO otherwise.
  *
  * @return Existing or newly created peer structure.
+ *         NULL if unknown and not requested @a create
  */
 struct CadetPeer *
-GCP_get_short (const GNUNET_PEER_Id peer)
+GCP_get_short (const GNUNET_PEER_Id peer, int create)
 {
-  return GCP_get (GNUNET_PEER_resolve2 (peer));
+  return GCP_get (GNUNET_PEER_resolve2 (peer), create);
 }
 
 
 /**
- * Try to connect to a peer on transport level.
+ * Function called once #GNUNET_TRANSPORT_offer_hello() is done.
+ * Marks the operation as finished.
  *
- * @param cls Closure (peer).
- * @param tc TaskContext.
+ * @param cls Closure (our `struct CadetPeer`).
  */
 static void
-try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+hello_offer_done (void *cls)
 {
   struct CadetPeer *peer = cls;
 
-  if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
-    return;
-
-  GNUNET_TRANSPORT_try_connect (transport_handle,
-                                GNUNET_PEER_resolve2 (peer->id), NULL, NULL);
+  peer->hello_offer = NULL;
 }
 
 
@@ -1801,12 +1380,14 @@ void
 GCP_connect (struct CadetPeer *peer)
 {
   struct CadetTunnel *t;
-  struct CadetPeerPath *p;
+  struct CadetPeerPath *path;
   struct CadetConnection *c;
   int rerun_search;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "peer_connect towards %s\n", GCP_2s (peer));
-
+  GCC_check_connections ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "peer_connect towards %s\n",
+       GCP_2s (peer));
   /* If we have a current hello, try to connect using it. */
   GCP_try_connect (peer);
 
@@ -1817,27 +1398,27 @@ GCP_connect (struct CadetPeer *peer)
   if (NULL != peer->path_head)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "  some path exists\n");
-    p = peer_get_best_path (peer);
-    if (NULL != p)
+    path = peer_get_best_path (peer);
+    if (NULL != path)
     {
       char *s;
 
-      s = path_2s (p);
+      s = path_2s (path);
       LOG (GNUNET_ERROR_TYPE_DEBUG, "  path to use: %s\n", s);
       GNUNET_free (s);
 
-      c = GCT_use_path (t, p);
+      c = GCT_use_path (t, path);
       if (NULL == c)
       {
         /* This case can happen when the path includes a first hop that is
          * not yet known to be connected.
          *
          * This happens quite often during testing when running cadet
-         * under valgrind: core connect notifications come very late and the
-         * DHT result has already come and created a valid path.
-         * In this case, the peer->connections hashmap will be NULL and
-         * tunnel_use_path will not be able to create a connection from that
-         * path.
+         * under valgrind: core connect notifications come very late
+         * and the DHT result has already come and created a valid
+         * path.  In this case, the peer->connections
+         * hashmaps will be NULL and tunnel_use_path will not be able
+         * to create a connection from that path.
          *
          * Re-running the DHT GET should give core time to callback.
          *
@@ -1864,13 +1445,16 @@ GCP_connect (struct CadetPeer *peer)
 
     GCP_stop_search (peer);
     delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
-    peer->search_delayed = GNUNET_SCHEDULER_add_delayed (delay, &delayed_search,
+    peer->search_delayed = GNUNET_SCHEDULER_add_delayed (delay,
+                                                         &delayed_search,
                                                          peer);
+    GCC_check_connections ();
     return;
   }
 
   if (GNUNET_NO == is_searching (peer))
     GCP_start_search (peer);
+  GCC_check_connections ();
 }
 
 
@@ -1911,9 +1495,11 @@ GCP_is_neighbor (const struct CadetPeer *peer)
 void
 GCP_add_tunnel (struct CadetPeer *peer)
 {
+  GCC_check_connections ();
   if (NULL != peer->tunnel)
     return;
   peer->tunnel = GCT_new (peer);
+  GCC_check_connections ();
 }
 
 
@@ -1926,38 +1512,29 @@ GCP_add_tunnel (struct CadetPeer *peer)
  *
  * @param peer Peer to add connection to.
  * @param c Connection to add.
- *
- * @return GNUNET_OK on success.
+ * @param pred #GNUNET_YES if we are predecessor, #GNUNET_NO if we are successor
  */
-int
+void
 GCP_add_connection (struct CadetPeer *peer,
-                    struct CadetConnection *c)
+                    struct CadetConnection *c,
+                    int pred)
 {
-  int result;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "adding connection %s\n", GCC_2s (c));
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "to peer %s\n", GCP_2s (peer));
-
-  if (NULL == peer->connections)
-  {
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Peer %s is not a neighbor!\n",
-         GCP_2s (peer));
-    return GNUNET_SYSERR;
-  }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "peer %s ok, has %u connections.\n",
-       GCP_2s (peer), GNUNET_CONTAINER_multihashmap_size (peer->connections));
-  result = GNUNET_CONTAINER_multihashmap_put (peer->connections,
-                                              GCC_get_h (c),
-                                              c,
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+       "adding connection %s\n",
+       GCC_2s (c));
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       " now has %u connections.\n",
+       "to peer %s\n",
+       GCP_2s (peer));
+  GNUNET_assert (NULL != peer->connections);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (peer->connections,
+                                                    GCC_get_h (c),
+                                                    c,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %s has now %u connections.\n",
+       GCP_2s (peer),
        GNUNET_CONTAINER_multihashmap_size (peer->connections));
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "result %u\n", result);
-
-  return result;
 }
 
 
@@ -1966,7 +1543,7 @@ GCP_add_connection (struct CadetPeer *peer,
  * is the shortest.
  *
  * @param peer Destination peer to add the path to.
- * @param path New path to add. Last peer must be the peer in arg 1.
+ * @param path New path to add. Last peer must be @c peer.
  *             Path will be either used of freed if already known.
  * @param trusted Do we trust that this path is real?
  *
@@ -1974,14 +1551,17 @@ GCP_add_connection (struct CadetPeer *peer,
  *         NULL on error.
  */
 struct CadetPeerPath *
-GCP_add_path (struct CadetPeer *peer, struct CadetPeerPath *path,
+GCP_add_path (struct CadetPeer *peer,
+              struct CadetPeerPath *path,
               int trusted)
 {
   struct CadetPeerPath *aux;
   unsigned int l;
   unsigned int l2;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n",
+  GCC_check_connections ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "adding path [%u] to peer %s\n",
        path->length, GCP_2s (peer));
 
   if (NULL == peer || NULL == path
@@ -2045,16 +1625,19 @@ GCP_add_path (struct CadetPeer *peer, struct CadetPeerPath *path,
       }
     }
   }
-  GNUNET_CONTAINER_DLL_insert_tail (peer->path_head, peer->path_tail,
+  GNUNET_CONTAINER_DLL_insert_tail (peer->path_head,
+                                   peer->path_tail,
                                     path);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "  added last\n");
 
 finish:
   if (NULL != peer->tunnel
-      && CONNECTIONS_PER_TUNNEL < GCT_count_connections (peer->tunnel))
+      && CONNECTIONS_PER_TUNNEL > GCT_count_connections (peer->tunnel)
+      && 2 < path->length) /* Direct paths are handled by core_connect */
   {
     GCP_connect (peer);
   }
+  GCC_check_connections ();
   return path;
 }
 
@@ -2096,37 +1679,43 @@ GCP_add_path_to_all (const struct CadetPeerPath *p, int confirmed)
 {
   unsigned int i;
 
-  /* TODO: invert and add */
+  /* TODO: invert and add to origin */
+  /* TODO: replace all "GCP_add_path" with this, make the other one static */
+  GCC_check_connections ();
   for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ;
   for (i++; i < p->length; i++)
   {
-    struct CadetPeer *aux;
+    struct CadetPeer *peer;
     struct CadetPeerPath *copy;
 
-    aux = GCP_get_short (p->peers[i]);
+    peer = GCP_get_short (p->peers[i], GNUNET_YES);
     copy = path_duplicate (p);
     copy->length = i + 1;
-    GCP_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed);
+    GCP_add_path (peer, copy, 3 > p->length ? GNUNET_NO : confirmed);
   }
+  GCC_check_connections ();
 }
 
 
 /**
- * Remove any path to the peer that has the extact same peers as the one given.
+ * Remove any path to the peer that has the exact same peers as the one given.
  *
  * @param peer Peer to remove the path from.
  * @param path Path to remove. Is always destroyed .
  */
 void
-GCP_remove_path (struct CadetPeer *peer, struct CadetPeerPath *path)
+GCP_remove_path (struct CadetPeer *peer,
+                struct CadetPeerPath *path)
 {
   struct CadetPeerPath *iter;
   struct CadetPeerPath *next;
 
+  GCC_check_connections ();
   GNUNET_assert (myid == path->peers[0]);
   GNUNET_assert (peer->id == path->peers[path->length - 1]);
 
-  LOG (GNUNET_ERROR_TYPE_INFO, "Removing path %p (%u) from %s\n",
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Removing path %p (%u) from %s\n",
        path, path->length, GCP_2s (peer));
 
   for (iter = peer->path_head; NULL != iter; iter = next)
@@ -2134,12 +1723,35 @@ GCP_remove_path (struct CadetPeer *peer, struct CadetPeerPath *path)
     next = iter->next;
     if (0 == path_cmp (path, iter))
     {
-      GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, iter);
+      GNUNET_CONTAINER_DLL_remove (peer->path_head,
+                                  peer->path_tail,
+                                  iter);
       if (iter != path)
         path_destroy (iter);
     }
   }
   path_destroy (path);
+  GCC_check_connections ();
+}
+
+
+/**
+ * Check that we are aware of a connection from a neighboring peer.
+ *
+ * @param peer Peer to the connection is with
+ * @param c Connection that should be in the map with this peer.
+ */
+void
+GCP_check_connection (const struct CadetPeer *peer,
+                      const struct CadetConnection *c)
+{
+  GNUNET_assert (NULL != peer);
+  GNUNET_assert (NULL != peer->connections);
+    return;
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_contains_value (peer->connections,
+                                                               GCC_get_h (c),
+                                                               c));
 }
 
 
@@ -2148,32 +1760,31 @@ GCP_remove_path (struct CadetPeer *peer, struct CadetPeerPath *path)
  *
  * @param peer Peer to remove connection from.
  * @param c Connection to remove.
- *
- * @return GNUNET_OK on success.
  */
-int
+void
 GCP_remove_connection (struct CadetPeer *peer,
                        const struct CadetConnection *c)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "removing connection %s\n", GCC_2s (c));
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "from peer %s\n", GCP_2s (peer));
-
-  if (NULL == peer || NULL == peer->connections)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Peer %s is not a neighbor!\n",
-         GCP_2s (peer));
-    return GNUNET_SYSERR;
-  }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "peer %s ok, has %u connections.\n",
-       GCP_2s (peer), GNUNET_CONTAINER_multihashmap_size (peer->connections));
-
-  return GNUNET_CONTAINER_multihashmap_remove (peer->connections,
-                                               GCC_get_h (c),
-                                               c);
+       "Removing connection %s\n",
+       GCC_2s (c));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "from peer %s\n",
+       GCP_2s (peer));
+  if ( (NULL == peer) ||
+       (NULL == peer->connections) )
+    return;
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (peer->connections,
+                                                       GCC_get_h (c),
+                                                       c));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %s remains with %u connections.\n",
+       GCP_2s (peer),
+       GNUNET_CONTAINER_multihashmap_size (peer->connections));
 }
 
+
 /**
  * Start the DHT search for new paths towards the peer: we don't have
  * enough good connections.
@@ -2186,7 +1797,8 @@ GCP_start_search (struct CadetPeer *peer)
   const struct GNUNET_PeerIdentity *id;
   struct CadetTunnel *t = peer->tunnel;
 
-  if (NULL != peer->search_h)
+  GCC_check_connections ();
+ if (NULL != peer->search_h)
   {
     GNUNET_break (0);
     return;
@@ -2210,6 +1822,7 @@ GCP_start_search (struct CadetPeer *peer)
   {
     GCT_change_cstate (t, CADET_TUNNEL_SEARCHING);
   }
+  GCC_check_connections ();
 }
 
 
@@ -2222,6 +1835,7 @@ GCP_start_search (struct CadetPeer *peer)
 void
 GCP_stop_search (struct CadetPeer *peer)
 {
+  GCC_check_connections ();
   if (NULL != peer->search_h)
   {
     GCD_search_stop (peer->search_h);
@@ -2232,6 +1846,7 @@ GCP_stop_search (struct CadetPeer *peer)
     GNUNET_SCHEDULER_cancel (peer->search_delayed);
     peer->search_delayed = NULL;
   }
+  GCC_check_connections ();
 }
 
 
@@ -2292,6 +1907,8 @@ GCP_set_tunnel (struct CadetPeer *peer, struct CadetTunnel *t)
 struct CadetTunnel *
 GCP_get_tunnel (const struct CadetPeer *peer)
 {
+  if (NULL == peer)
+    return NULL;
   return peer->tunnel;
 }
 
@@ -2303,12 +1920,14 @@ GCP_get_tunnel (const struct CadetPeer *peer)
  * @param hello Hello message.
  */
 void
-GCP_set_hello (struct CadetPeer *peer, const struct GNUNET_HELLO_Message *hello)
+GCP_set_hello (struct CadetPeer *peer,
+              const struct GNUNET_HELLO_Message *hello)
 {
   struct GNUNET_HELLO_Message *old;
   size_t size;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "set hello for %s\n", GCP_2s (peer));
+  GCC_check_connections ();
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "set hello for %s\n", GCP_2s (peer));
   if (NULL == hello)
     return;
 
@@ -2316,17 +1935,15 @@ GCP_set_hello (struct CadetPeer *peer, const struct GNUNET_HELLO_Message *hello)
   if (NULL == old)
   {
     size = GNUNET_HELLO_size (hello);
-    LOG (GNUNET_ERROR_TYPE_DEBUG, " new (%u bytes)\n", size);
     peer->hello = GNUNET_malloc (size);
-    memcpy (peer->hello, hello, size);
+    GNUNET_memcpy (peer->hello, hello, size);
   }
   else
   {
     peer->hello = GNUNET_HELLO_merge (old, hello);
-    LOG (GNUNET_ERROR_TYPE_DEBUG, " merge into %p (%u bytes)\n",
-         peer->hello, GNUNET_HELLO_size (hello));
     GNUNET_free (old);
   }
+  GCC_check_connections ();
 }
 
 
@@ -2370,70 +1987,34 @@ GCP_try_connect (struct CadetPeer *peer)
   struct GNUNET_HELLO_Message *hello;
   struct GNUNET_MessageHeader *mh;
 
-  if (NULL == transport_handle)
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                            "CADET",
+                                            "DISABLE_TRY_CONNECT"))
+    return;
+  GCC_check_connections ();
+  if (GNUNET_YES == GCP_is_neighbor (peer))
     return;
-
   hello = GCP_get_hello (peer);
   if (NULL == hello)
     return;
 
   mh = GNUNET_HELLO_get_header (hello);
-  GNUNET_TRANSPORT_offer_hello (transport_handle, mh, try_connect, peer);
-}
-
-
-/**
- * Check if the given ECDH key is correct for the peer.
- *
- * This function caches the results if the key has been previoulsy checked,
- * otherwise checks that the key is signed with the peer's ID (EdDSA key).
- *
- * TODO: save the cached public key to permanent storage / peerinfo.
- *
- * @param peer Peer whose key to check.
- * @param key ECDH key to check.
- * @param purpose Purpose of the signature (followed by the key).
- * @param sig Signature with the peer's EdDSA key (PeerID).
- */
-int
-GCP_check_key (struct CadetPeer *peer,
-               const struct GNUNET_CRYPTO_EcdhePublicKey *key,
-               const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-               const struct GNUNET_CRYPTO_EddsaSignature *sig)
-{
-  struct GNUNET_CRYPTO_EddsaPublicKey *pub;
-  int verified;
-
-  /* Is it the same as the cached key? */
-  if (0 == memcmp (&peer->ax_key, key, sizeof (*key)))
-    return GNUNET_OK;
-
-  /* New key, verify. */
-  pub = (struct GNUNET_CRYPTO_EddsaPublicKey *) GCP_get_id (peer);
-  verified = GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_CADET_AXKX,
-                                         purpose, sig, pub);
-
-  if (GNUNET_OK != verified)
-    return GNUNET_SYSERR;
-
-  /* Cache key for later. */
-  peer->ax_key = *key;
-  return GNUNET_OK;
-}
-
-
-/**
- * Get the Identity ECDH key of the peer.
- *
- * @param peer Peer whose key to get.
- *
- * @return Peer's permanent ECDH key (might be all 0: unknown).
- *
- */
-struct GNUNET_CRYPTO_EcdhePublicKey *
-GCP_get_ecdh_key (struct CadetPeer *peer)
-{
-  return &peer->ax_key;
+  if (NULL != peer->hello_offer)
+  {
+    GNUNET_TRANSPORT_offer_hello_cancel (peer->hello_offer);
+    peer->hello_offer = NULL;
+  }
+  peer->hello_offer = GNUNET_TRANSPORT_offer_hello (cfg,
+                                                    mh,
+                                                    &hello_offer_done,
+                                                    peer);
+  if (NULL == peer->connectivity_suggestion)
+    peer->connectivity_suggestion
+      = GNUNET_ATS_connectivity_suggest (ats_ch,
+                                         GNUNET_PEER_resolve2 (peer->id),
+                                         1 /* strength */);
+  GCC_check_connections ();
 }
 
 
@@ -2447,8 +2028,8 @@ GCP_get_ecdh_key (struct CadetPeer *peer)
  */
 void
 GCP_notify_broken_link (struct CadetPeer *peer,
-                        struct GNUNET_PeerIdentity *peer1,
-                        struct GNUNET_PeerIdentity *peer2)
+                        const struct GNUNET_PeerIdentity *peer1,
+                        const struct GNUNET_PeerIdentity *peer2)
 {
   struct CadetPeerPath *iter;
   struct CadetPeerPath *next;
@@ -2456,6 +2037,7 @@ GCP_notify_broken_link (struct CadetPeer *peer,
   GNUNET_PEER_Id p1;
   GNUNET_PEER_Id p2;
 
+  GCC_check_connections ();
   p1 = GNUNET_PEER_search (peer1);
   p2 = GNUNET_PEER_search (peer2);
 
@@ -2484,6 +2066,7 @@ GCP_notify_broken_link (struct CadetPeer *peer,
       }
     }
   }
+  GCC_check_connections ();
 }
 
 
@@ -2507,6 +2090,34 @@ GCP_count_paths (const struct CadetPeer *peer)
 }
 
 
+/**
+ * Iterate over the paths to a peer.
+ *
+ * @param peer Peer to get path info.
+ * @param callback Function to call for every path.
+ * @param cls Closure for @a callback.
+ *
+ * @return Number of iterated paths.
+ */
+unsigned int
+GCP_iterate_paths (struct CadetPeer *peer,
+                   GCP_path_iterator callback,
+                   void *cls)
+{
+  struct CadetPeerPath *iter;
+  unsigned int i;
+
+  for (iter = peer->path_head, i = 0; NULL != iter; iter = iter->next)
+  {
+    i++;
+    if (GNUNET_YES != callback (cls, peer, iter))
+      break;
+  }
+
+  return i;
+}
+
+
 /**
  * Iterate all known peers.
  *
@@ -2514,9 +2125,14 @@ GCP_count_paths (const struct CadetPeer *peer)
  * @param cls Closure for @c iter.
  */
 void
-GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter, void *cls)
+GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter,
+                 void *cls)
 {
-  GNUNET_CONTAINER_multipeermap_iterate (peers, iter, cls);
+  GCC_check_connections ();
+  GNUNET_CONTAINER_multipeermap_iterate (peers,
+                                         iter,
+                                         cls);
+  GCC_check_connections ();
 }
 
 
@@ -2534,3 +2150,6 @@ GCP_2s (const struct CadetPeer *peer)
     return "(NULL)";
   return GNUNET_i2s (GNUNET_PEER_resolve2 (peer->id));
 }
+
+
+/* end of gnunet-service-cadet_peer.c */