gnunet-service-testbed_oc.c

Go to the documentation of this file.

/*
   This file is part of GNUnet.
   Copyright (C) 2008--2016 GNUnet e.V.

   GNUnet is free software: you can redistribute it and/or modify it
   under the terms of the GNU Affero General Public License as published
   by the Free Software Foundation, either version 3 of the License,
   or (at your option) any later version.

   GNUnet is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Affero General Public License for more details.

   You should have received a copy of the GNU Affero General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */

#include "gnunet-service-testbed.h"
#include "gnunet-service-testbed_connectionpool.h"
#include "gnunet_transport_hello_service.h"

#ifdef LOG
#undef LOG
#endif
#define LOG(kind, ...)                                   \
  GNUNET_log_from(kind, "testbed-OC", __VA_ARGS__)


struct ConnectivitySuggestContext {
  struct GNUNET_TRANSPORT_CoreHandle *th_;

  const struct GNUNET_CONFIGURATION_Handle *cfg;

  struct GST_ConnectionPool_GetHandle *cgh_p2_th;

  struct GST_ConnectionPool_GetHandle *cgh_p2_ats;

  struct GNUNET_ATS_ConnectivitySuggestHandle *csh;
};


enum OverlayConnectContextType {
  OCC_TYPE_LOCAL,

  OCC_TYPE_REMOTE_SLAVE,

  OCC_TYPE_REMOTE_LATERAL
};


struct LocalPeer2Context {
  struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;

  struct ConnectivitySuggestContext tcc;
};


struct RemotePeer2Context {
  struct GNUNET_TESTBED_Controller *p2c;

  struct OperationContext *opc;

  struct NeighbourConnectNotification *ncn;

  struct Neighbour *p2n;
};

struct OverlayConnectContext {
  struct OverlayConnectContext *next;

  struct OverlayConnectContext *prev;

  struct GNUNET_SERVICE_Client *client;

  struct Peer *peer;

  struct GNUNET_TRANSPORT_CoreHandle *p1th_;

  struct GST_ConnectionPool_GetHandle *cgh_p1th;

  struct GST_ConnectionPool_GetHandle *cgh_ch;

  struct GNUNET_MessageHeader *hello;

  struct GNUNET_TRANSPORT_HelloGetHandle *ghh;

  char *emsg;

  union {
    struct LocalPeer2Context local;

    struct RemotePeer2Context remote;
  } p2ctx;

  struct GNUNET_PeerIdentity peer_identity;

  struct GNUNET_PeerIdentity other_peer_identity;

  uint64_t op_id;

  struct GNUNET_SCHEDULER_Task *send_hello_task;

  struct GNUNET_SCHEDULER_Task *timeout_task;

  struct GNUNET_SCHEDULER_Task *cleanup_task;

  enum OverlayConnectContextType type;

  uint32_t other_peer_id;
};


struct RemoteOverlayConnectCtx {
  struct RemoteOverlayConnectCtx *next;

  struct RemoteOverlayConnectCtx *prev;

  struct Peer *peer;

  struct GNUNET_MessageHeader *hello;

  struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;

  struct ConnectivitySuggestContext tcc;

  struct GNUNET_PeerIdentity a_id;

  struct GNUNET_SCHEDULER_Task *attempt_connect_task_id;

  struct GNUNET_SCHEDULER_Task *timeout_rocc_task_id;

  uint64_t op_id;
};


static struct OverlayConnectContext *occq_head;

static struct OverlayConnectContext *occq_tail;

static struct RemoteOverlayConnectCtx *roccq_head;

static struct RemoteOverlayConnectCtx *roccq_tail;


void
GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
{
  struct RegisteredHostContext *rhc = focc->rhc;

  GNUNET_CONTAINER_DLL_remove(rhc->focc_dll_head,
                              rhc->focc_dll_tail,
                              focc);
  GNUNET_free_non_null(focc->orig_msg);
  GNUNET_free(focc);
}


static void
forwarded_overlay_connect_timeout(void *cls)
{
  struct ForwardedOperationContext *fopc = cls;
  struct RegisteredHostContext *rhc;
  struct ForwardedOverlayConnectContext *focc;

  fopc->timeout_task = NULL;
  rhc = fopc->cls;
  focc = rhc->focc_dll_head;
  LOG_DEBUG("Overlay linking between peers %u and %u failed\n",
            focc->peer1,
            focc->peer2);
  GST_cleanup_focc(focc);
  GST_forwarded_operation_timeout(fopc);
  if (NULL != rhc->focc_dll_head)
    GST_process_next_focc(rhc);
}


static void
forwarded_overlay_connect_listener(void *cls,
                                   const struct GNUNET_MessageHeader *msg)
{
  struct ForwardedOperationContext *fopc = cls;
  struct RegisteredHostContext *rhc;
  struct ForwardedOverlayConnectContext *focc;

  rhc = fopc->cls;
  GST_forwarded_operation_reply_relay(cls, msg);
  focc = rhc->focc_dll_head;
  GST_cleanup_focc(focc);
  if (NULL != rhc->focc_dll_head)
    GST_process_next_focc(rhc);
}


void
GST_process_next_focc(struct RegisteredHostContext *rhc)
{
  struct ForwardedOperationContext *fopc;
  struct ForwardedOverlayConnectContext *focc;
  struct Peer *peer;
  struct Slave *slave;

  focc = rhc->focc_dll_head;
  GNUNET_assert(NULL != focc);
  GNUNET_assert(RHC_DONE == rhc->state);
  GNUNET_assert(VALID_PEER_ID(focc->peer1));
  peer = GST_peer_list[focc->peer1];
  GNUNET_assert(GNUNET_YES == peer->is_remote);
  GNUNET_assert(NULL != (slave = peer->details.remote.slave));
  fopc = GNUNET_new(struct ForwardedOperationContext);
  fopc->client = focc->client;
  fopc->operation_id = focc->operation_id;
  fopc->cls = rhc;
  fopc->type = OP_OVERLAY_CONNECT;
  fopc->opc =
    GNUNET_TESTBED_forward_operation_msg_(slave->controller,
                                          focc->operation_id,
                                          focc->orig_msg,
                                          &forwarded_overlay_connect_listener,
                                          fopc);
  GNUNET_free(focc->orig_msg);
  focc->orig_msg = NULL;
  fopc->timeout_task = GNUNET_SCHEDULER_add_delayed(GST_timeout,
                                                    &forwarded_overlay_connect_timeout,
                                                    fopc);
  GNUNET_CONTAINER_DLL_insert_tail(fopcq_head,
                                   fopcq_tail,
                                   fopc);
}


static void
cleanup_occ_lp2c(struct LocalPeer2Context *lp2c)
{
  if (NULL != lp2c->ohh)
    {
      GNUNET_TRANSPORT_offer_hello_cancel(lp2c->ohh);
      lp2c->ohh = NULL;
    }
  if (NULL != lp2c->tcc.cgh_p2_th)
    {
      GST_connection_pool_get_handle_done(lp2c->tcc.cgh_p2_th);
      lp2c->tcc.cgh_p2_th = NULL;
    }
  if (NULL != lp2c->tcc.cgh_p2_ats)
    {
      GST_connection_pool_get_handle_done(lp2c->tcc.cgh_p2_ats);
      lp2c->tcc.cgh_p2_ats = NULL;
    }
  if (NULL != lp2c->tcc.csh)
    {
      GNUNET_ATS_connectivity_suggest_cancel(lp2c->tcc.csh);
      lp2c->tcc.csh = NULL;
    }
}


static void
cleanup_occ_rp2c(struct RemotePeer2Context *rp2c)
{
  if (NULL != rp2c->opc)
    {
      GNUNET_TESTBED_forward_operation_msg_cancel_(rp2c->opc);
      rp2c->opc = NULL;
    }
  if (NULL != rp2c->ncn)
    {
      GST_neighbour_get_connection_cancel(rp2c->ncn);
      rp2c->ncn = NULL;
    }
  if ((NULL != rp2c->p2c) && (NULL != rp2c->p2n))
    {
      GST_neighbour_release_connection(rp2c->p2n);
      rp2c->p2n = NULL;
    }
}

#define PEER_EXPIRED(peer)                      \
  ((GNUNET_YES == peer->destroy_flag) && (0 == peer->reference_cnt))

static void
cleanup_occ(struct OverlayConnectContext *occ)
{
  struct Peer *peer2;

  LOG_DEBUG("0x%llx: Cleaning up occ\n",
            occ->op_id);
  GNUNET_free_non_null(occ->emsg);
  GNUNET_free_non_null(occ->hello);
  if (NULL != occ->send_hello_task)
    GNUNET_SCHEDULER_cancel(occ->send_hello_task);
  if (NULL != occ->cleanup_task)
    GNUNET_SCHEDULER_cancel(occ->cleanup_task);
  if (NULL != occ->timeout_task)
    GNUNET_SCHEDULER_cancel(occ->timeout_task);
  if (NULL != occ->cgh_ch)
    GST_connection_pool_get_handle_done(occ->cgh_ch);
  if (NULL != occ->ghh)
    GNUNET_TRANSPORT_hello_get_cancel(occ->ghh);
  GST_connection_pool_get_handle_done(occ->cgh_p1th);
  GNUNET_assert(NULL != GST_peer_list);
  GNUNET_assert(occ->peer->reference_cnt > 0);
  occ->peer->reference_cnt--;
  if (PEER_EXPIRED(occ->peer))
    GST_destroy_peer(occ->peer);
  switch (occ->type)
    {
    case OCC_TYPE_LOCAL:
      peer2 = GST_peer_list[occ->other_peer_id];
      GNUNET_assert(peer2->reference_cnt > 0);
      peer2->reference_cnt--;
      if (PEER_EXPIRED(peer2))
        GST_destroy_peer(peer2);
      cleanup_occ_lp2c(&occ->p2ctx.local);
      break;

    case OCC_TYPE_REMOTE_SLAVE:
    case OCC_TYPE_REMOTE_LATERAL:
      cleanup_occ_rp2c(&occ->p2ctx.remote);
      break;
    }
  GNUNET_CONTAINER_DLL_remove(occq_head,
                              occq_tail,
                              occ);
  GNUNET_free(occ);
}


static void
do_cleanup_occ(void *cls)
{
  struct OverlayConnectContext *occ = cls;

  occ->cleanup_task = NULL;
  cleanup_occ(occ);
}


static void
timeout_overlay_connect(void *cls)
{
  struct OverlayConnectContext *occ = cls;

  GNUNET_assert(NULL != occ->timeout_task);
  occ->timeout_task = NULL;
  /* LOG (GNUNET_ERROR_TYPE_WARNING, */
  /*      "0x%llx: Timeout while connecting peers %u and %u: %s\n", occ->op_id, */
  /*      occ->peer->id, occ->other_peer_id, occ->emsg); */
  GST_send_operation_fail_msg(occ->client,
                              occ->op_id,
                              occ->emsg);
  cleanup_occ(occ);
}


void
GST_notify_client_disconnect_oc(struct GNUNET_SERVICE_Client *client)
{
  struct ForwardedOperationContext *fopc;
  struct ForwardedOperationContext *fopcn;
  struct OverlayConnectContext *occ;
  struct OverlayConnectContext *occn;

  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
    {
      fopcn = fopc->next;
      if (fopc->client == client)
        {
          GNUNET_SCHEDULER_cancel(fopc->timeout_task);
          GST_forwarded_operation_timeout(fopc);
        }
    }
  for (occ = occq_head; NULL != occ; occ = occn)
    {
      occn = occ->next;
      if (occ->client == client)
        cleanup_occ(occ);
    }
  // FIXME: implement clean up for client_keep replacements!
}




static void
send_overlay_connect_success_msg(struct OverlayConnectContext *occ)
{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_ConnectionEventMessage *msg;

  LOG_DEBUG("0x%llx: Peers connected - Sending overlay connect success\n",
            occ->op_id);
  env = GNUNET_MQ_msg(msg,
                      GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT);
  msg->event_type = htonl(GNUNET_TESTBED_ET_CONNECT);
  msg->peer1 = htonl(occ->peer->id);
  msg->peer2 = htonl(occ->other_peer_id);
  msg->operation_id = GNUNET_htonll(occ->op_id);
  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(occ->client),
                 env);
}


static void
overlay_connect_notify(void *cls,
                       const struct GNUNET_PeerIdentity *new_peer)
{
  struct OverlayConnectContext *occ = cls;
  char *new_peer_str;
  char *other_peer_str;

  LOG_DEBUG("Overlay connect notify\n");
  if (0 ==
      memcmp(new_peer, &occ->peer_identity,
             sizeof(struct GNUNET_PeerIdentity)))
    return;
  new_peer_str = GNUNET_strdup(GNUNET_i2s(new_peer));
  other_peer_str = GNUNET_strdup(GNUNET_i2s(&occ->other_peer_identity));
  if (0 !=
      memcmp(new_peer,
             &occ->other_peer_identity,
             sizeof(struct GNUNET_PeerIdentity)))
    {
      LOG_DEBUG("Unexpected peer %s connected when expecting peer %s\n",
                new_peer_str,
                other_peer_str);
      GNUNET_free(new_peer_str);
      GNUNET_free(other_peer_str);
      return;
    }
  GNUNET_free(new_peer_str);
  LOG_DEBUG("0x%llx: Peer %s connected to peer %s\n",
            occ->op_id,
            other_peer_str,
            GNUNET_i2s(&occ->peer_identity));
  GNUNET_free(other_peer_str);
  if (NULL != occ->send_hello_task)
    {
      GNUNET_SCHEDULER_cancel(occ->send_hello_task);
      occ->send_hello_task = NULL;
    }
  GNUNET_assert(NULL != occ->timeout_task);
  GNUNET_SCHEDULER_cancel(occ->timeout_task);
  occ->timeout_task = NULL;
  switch (occ->type)
    {
    case OCC_TYPE_LOCAL:
      cleanup_occ_lp2c(&occ->p2ctx.local);
      break;

    case OCC_TYPE_REMOTE_SLAVE:
    case OCC_TYPE_REMOTE_LATERAL:
      cleanup_occ_rp2c(&occ->p2ctx.remote);
      break;
    }
  GNUNET_free_non_null(occ->emsg);
  occ->emsg = NULL;
  send_overlay_connect_success_msg(occ);
  occ->cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup_occ,
                                               occ);
}


static void
occ_cache_get_handle_ats_occ_cb(void *cls,
                                struct GNUNET_CORE_Handle *ch,
                                struct GNUNET_TRANSPORT_CoreHandle *th,
                                struct GNUNET_ATS_ConnectivityHandle *ac,
                                const struct GNUNET_PeerIdentity *my_identity,
                                const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct OverlayConnectContext *occ = cls;
  struct LocalPeer2Context *lp2c;

  GNUNET_assert(OCC_TYPE_LOCAL == occ->type);
  GNUNET_assert(NULL != occ->timeout_task);
  GNUNET_free_non_null(occ->emsg);
  if (NULL == ac)
    {
      GNUNET_asprintf(&occ->emsg,
                      "0x%llx: Failed to connect to ATS of peer with id: %u",
                      occ->op_id,
                      occ->peer->id);
      GNUNET_SCHEDULER_cancel(occ->timeout_task);
      occ->timeout_task =
        GNUNET_SCHEDULER_add_now(&timeout_overlay_connect,
                                 occ);
      return;
    }
  occ->emsg = NULL;

  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout during GNUNET_ATS_connectivity_suggest() at peer %s",
                  occ->op_id,
                  GNUNET_i2s(&occ->other_peer_identity));

  lp2c = &occ->p2ctx.local;
  lp2c->tcc.csh =
    GNUNET_ATS_connectivity_suggest(ac,
                                    &occ->peer_identity,
                                    1);
}


static void
occ_cache_get_handle_ats_rocc_cb(void *cls,
                                 struct GNUNET_CORE_Handle *ch,
                                 struct GNUNET_TRANSPORT_CoreHandle *th,
                                 struct GNUNET_ATS_ConnectivityHandle *ac,
                                 const struct GNUNET_PeerIdentity *my_identity,
                                 const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct RemoteOverlayConnectCtx *rocc = cls;

  rocc->tcc.csh =
    GNUNET_ATS_connectivity_suggest(ac,
                                    &rocc->a_id,
                                    1);
}


static void
send_hello(void *cls);


static void
occ_hello_sent_cb(void *cls)
{
  struct OverlayConnectContext *occ = cls;
  struct LocalPeer2Context *lp2c;
  struct Peer *peer2;

  GNUNET_assert(OCC_TYPE_LOCAL == occ->type);
  GNUNET_assert(NULL != occ->timeout_task);
  lp2c = &occ->p2ctx.local;
  lp2c->ohh = NULL;

  GNUNET_assert(NULL == occ->send_hello_task);
  GNUNET_free_non_null(occ->emsg);

  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while acquiring ATS of %s from cache",
                  occ->op_id,
                  GNUNET_i2s(&occ->other_peer_identity));
  GNUNET_assert(NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
  lp2c->tcc.cgh_p2_ats =
    GST_connection_pool_get_handle(occ->other_peer_id,
                                   peer2->details.local.cfg,
                                   GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY,
                                   &occ_cache_get_handle_ats_occ_cb,
                                   occ, NULL, NULL, NULL);
}


static void
send_hello_thru_rocc(struct OverlayConnectContext *occ)
{
  struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg;
  char *other_peer_str;
  uint16_t msize;
  uint16_t hello_size;

  GNUNET_assert(OCC_TYPE_LOCAL != occ->type);
  GNUNET_assert(NULL != occ->hello);
  other_peer_str = GNUNET_strdup(GNUNET_i2s(&occ->other_peer_identity));
  LOG_DEBUG("0x%llx: Offering HELLO of %s (size: %u) to %s via Remote Overlay Request\n",
            occ->op_id,
            GNUNET_i2s(&occ->peer_identity),
            ntohs(occ->hello->size),
            other_peer_str);
  GNUNET_free(other_peer_str);
  hello_size = ntohs(occ->hello->size);
  msize = sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hello_size;
  msg = GNUNET_malloc(msize);
  msg->header.type =
    htons(GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT);
  msg->header.size = htons(msize);
  msg->peer = htonl(occ->other_peer_id);
  msg->operation_id = GNUNET_htonll(occ->op_id);
  msg->peer_identity = occ->peer_identity;
  GNUNET_memcpy(msg->hello,
                occ->hello,
                hello_size);
  GNUNET_TESTBED_queue_message_(occ->p2ctx.remote.p2c,
                                &msg->header);
}


static void
send_hello(void *cls)
{
  struct OverlayConnectContext *occ = cls;
  struct LocalPeer2Context *lp2c;
  char *other_peer_str;

  occ->send_hello_task = NULL;
  GNUNET_assert(NULL != occ->timeout_task);
  GNUNET_assert(NULL != occ->hello);
  if (OCC_TYPE_LOCAL != occ->type)
    {
      send_hello_thru_rocc(occ);
      return;
    }
  lp2c = &occ->p2ctx.local;
  other_peer_str = GNUNET_strdup(GNUNET_i2s(&occ->other_peer_identity));
  LOG_DEBUG("0x%llx: Offering HELLO of %s to %s\n",
            occ->op_id,
            GNUNET_i2s(&occ->peer_identity),
            other_peer_str);
  GNUNET_free(other_peer_str);
  lp2c->ohh =
    GNUNET_TRANSPORT_offer_hello(lp2c->tcc.cfg,
                                 occ->hello,
                                 &occ_hello_sent_cb,
                                 occ);
  if (NULL == lp2c->ohh)
    {
      GNUNET_break(0);
      occ->send_hello_task =
        GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
                                       (GNUNET_TIME_UNIT_MILLISECONDS,
                                       100 +
                                       GNUNET_CRYPTO_random_u32
                                         (GNUNET_CRYPTO_QUALITY_WEAK, 500)),
                                     &send_hello, occ);
    }
}


static void
p2_transport_connect_cache_callback(void *cls,
                                    struct GNUNET_CORE_Handle *ch,
                                    struct GNUNET_TRANSPORT_CoreHandle *th,
                                    struct GNUNET_ATS_ConnectivityHandle *ac,
                                    const struct GNUNET_PeerIdentity *ignore_,
                                    const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct OverlayConnectContext *occ = cls;

  GNUNET_assert(OCC_TYPE_LOCAL == occ->type);
  if (NULL == th)
    {
      GNUNET_asprintf(&occ->emsg,
                      "0x%llx: Cannot connect to TRANSPORT of %s",
                      occ->op_id,
                      GNUNET_i2s(&occ->other_peer_identity));
      GNUNET_SCHEDULER_cancel(occ->timeout_task);
      occ->timeout_task =
        GNUNET_SCHEDULER_add_now(&timeout_overlay_connect, occ);
      return;
    }
  occ->p2ctx.local.tcc.th_ = th;
  occ->p2ctx.local.tcc.cfg = cfg;
  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while offering HELLO to %s",
                  occ->op_id,
                  GNUNET_i2s(&occ->other_peer_identity));
  occ->send_hello_task = GNUNET_SCHEDULER_add_now(&send_hello, occ);
}


static void
p2_transport_connect(struct OverlayConnectContext *occ)
{
  struct Peer *peer2;

  /* HUH? Why to *obtain* HELLO? Seems we use this to *SEND* the
     HELLO! */
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Connecting to transport of peer %s to obtain HELLO\n",
             GNUNET_i2s(&occ->other_peer_identity));
  GNUNET_assert(NULL == occ->emsg);
  GNUNET_assert(NULL != occ->hello);
  GNUNET_assert(NULL == occ->ghh);
  GNUNET_assert(NULL == occ->p1th_);
  GNUNET_assert(NULL == occ->cgh_p1th);
  if (OCC_TYPE_LOCAL == occ->type)
    {
      GNUNET_assert(NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
      occ->p2ctx.local.tcc.cgh_p2_th =
        GST_connection_pool_get_handle(occ->other_peer_id,
                                       peer2->details.local.cfg,
                                       GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
                                       &p2_transport_connect_cache_callback,
                                       occ, NULL, NULL, NULL);
      return;
    }
  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while offering HELLO to %s",
                  occ->op_id,
                  GNUNET_i2s(&occ->other_peer_identity));
  occ->send_hello_task = GNUNET_SCHEDULER_add_now(&send_hello, occ);
}


static int
test_address(void *cls,
             const struct GNUNET_HELLO_Address *address,
             struct GNUNET_TIME_Absolute expiration)
{
  int *empty = cls;

  *empty = GNUNET_NO;
  return GNUNET_OK;
}


static void
hello_update_cb(void *cls,
                const struct GNUNET_MessageHeader *hello)
{
  struct OverlayConnectContext *occ = cls;
  int empty;
  uint16_t msize;

  msize = ntohs(hello->size);
  empty = GNUNET_YES;
  (void)GNUNET_HELLO_iterate_addresses((const struct GNUNET_HELLO_Message *)
                                       hello, GNUNET_NO,
                                       &test_address,
                                       &empty);
  if (GNUNET_YES == empty)
    {
      LOG_DEBUG("0x%llx: HELLO of %s is empty\n",
                occ->op_id,
                GNUNET_i2s(&occ->peer_identity));
      return;
    }
  LOG_DEBUG("0x%llx: Received HELLO of %s\n",
            occ->op_id,
            GNUNET_i2s(&occ->peer_identity));
  occ->hello = GNUNET_malloc(msize);
  GST_cache_add_hello(occ->peer->id, hello);
  GNUNET_memcpy(occ->hello, hello, msize);
  GNUNET_TRANSPORT_hello_get_cancel(occ->ghh);
  occ->ghh = NULL;
  GST_connection_pool_get_handle_done(occ->cgh_p1th);
  occ->cgh_p1th = NULL;
  occ->p1th_ = NULL;
  GNUNET_free_non_null(occ->emsg);
  occ->emsg = NULL;
  p2_transport_connect(occ);
}


static void
p1_transport_connect_cache_callback(void *cls,
                                    struct GNUNET_CORE_Handle *ch,
                                    struct GNUNET_TRANSPORT_CoreHandle *th,
                                    struct GNUNET_ATS_ConnectivityHandle *ac,
                                    const struct GNUNET_PeerIdentity *ignore_,
                                    const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct OverlayConnectContext *occ = cls;

  GNUNET_free_non_null(occ->emsg);
  occ->emsg = NULL;
  if (NULL == th)
    {
      GNUNET_asprintf(&occ->emsg,
                      "0x%llx: Cannot connect to TRANSPORT of %s",
                      occ->op_id,
                      GNUNET_i2s(&occ->peer_identity));
      GNUNET_SCHEDULER_cancel(occ->timeout_task);
      occ->timeout_task =
        GNUNET_SCHEDULER_add_now(&timeout_overlay_connect, occ);
      return;
    }
  GNUNET_assert(NULL == occ->p1th_);
  GNUNET_assert(NULL != occ->cgh_p1th);
  occ->p1th_ = th;
  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while acquiring HELLO of peer %s",
                  occ->op_id,
                  GNUNET_i2s(&occ->peer_identity));
  occ->ghh = GNUNET_TRANSPORT_hello_get(cfg,
                                        GNUNET_TRANSPORT_AC_ANY,
                                        &hello_update_cb,
                                        occ);
}


static void
occ_cache_get_handle_core_cb(void *cls,
                             struct GNUNET_CORE_Handle *ch,
                             struct GNUNET_TRANSPORT_CoreHandle *th,
                             struct GNUNET_ATS_ConnectivityHandle *ac,
                             const struct GNUNET_PeerIdentity *my_identity,
                             const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct OverlayConnectContext *occ = cls;
  const struct GNUNET_MessageHeader *hello;

  GNUNET_assert(NULL != occ->timeout_task);
  GNUNET_free_non_null(occ->emsg);
  if ((NULL == ch) || (NULL == my_identity))
    {
      GNUNET_asprintf(&occ->emsg,
                      "0x%llx: Failed to connect to CORE of peer with "
                      "id: %u",
                      occ->op_id,
                      occ->peer->id);
      GNUNET_SCHEDULER_cancel(occ->timeout_task);
      occ->timeout_task =
        GNUNET_SCHEDULER_add_now(&timeout_overlay_connect, occ);
      return;
    }
  occ->emsg = NULL;
  if (NULL !=
      GNUNET_CORE_get_mq(ch,
                         &occ->other_peer_identity))
    {
      LOG_DEBUG("0x%llx: Target peer already connected\n",
                occ->op_id);
      GNUNET_SCHEDULER_cancel(occ->timeout_task);
      occ->timeout_task = NULL;
      send_overlay_connect_success_msg(occ);
      occ->cleanup_task = GNUNET_SCHEDULER_add_now(&do_cleanup_occ, occ);
      return;
    }
  occ->peer_identity = *my_identity;
  LOG_DEBUG("0x%llx: Acquiring HELLO of peer %s\n",
            occ->op_id,
            GNUNET_i2s(&occ->peer_identity));
  /* Lookup for HELLO in hello cache */
  if (NULL != (hello = GST_cache_lookup_hello(occ->peer->id)))
    {
      LOG_DEBUG("0x%llx: HELLO of peer %s found in cache\n",
                occ->op_id,
                GNUNET_i2s(&occ->peer_identity));
      occ->hello = GNUNET_copy_message(hello);
      p2_transport_connect(occ);
      return;
    }
  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while acquiring TRANSPORT of %s from cache",
                  occ->op_id,
                  GNUNET_i2s(&occ->peer_identity));
  occ->cgh_p1th =
    GST_connection_pool_get_handle(occ->peer->id,
                                   occ->peer->details.local.cfg,
                                   GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
                                   p1_transport_connect_cache_callback,
                                   occ,
                                   NULL, NULL, NULL);
}


static void
overlay_connect_get_config(void *cls,
                           const struct GNUNET_MessageHeader *msg)
{
  struct OverlayConnectContext *occ = cls;
  struct RemotePeer2Context *rp2c;
  const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *cmsg;

  GNUNET_assert(OCC_TYPE_LOCAL != occ->type);
  rp2c = &occ->p2ctx.remote;
  rp2c->opc = NULL;
  GNUNET_assert(NULL != occ->timeout_task);
  if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION != ntohs(msg->type))
    {
      GNUNET_SCHEDULER_cancel(occ->timeout_task);
      occ->timeout_task =
        GNUNET_SCHEDULER_add_now(&timeout_overlay_connect, occ);
    }
  cmsg =
    (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *)msg;
  occ->other_peer_identity = cmsg->peer_identity;
  GNUNET_free_non_null(occ->emsg);
  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while connecting to CORE of peer with "
                  "id: %u",
                  occ->op_id,
                  occ->peer->id);
  occ->cgh_ch =
    GST_connection_pool_get_handle(occ->peer->id,
                                   occ->peer->details.local.cfg,
                                   GST_CONNECTIONPOOL_SERVICE_CORE,
                                   occ_cache_get_handle_core_cb,
                                   occ,
                                   &occ->other_peer_identity,
                                   &overlay_connect_notify,
                                   occ);
  return;
}


static void
host_registration_comp(void *cls, const char *emsg)
{
  struct RegisteredHostContext *rhc = cls;

  rhc->state = RHC_DONE;
  GST_process_next_focc(rhc);
}


static int
reghost_match_iterator(void *cls,
                       const struct GNUNET_HashCode *key,
                       void *value)
{
  struct RegisteredHostContext **rh = cls;
  struct RegisteredHostContext *rh_val = value;

  if ((rh_val->host == (*rh)->host) && (rh_val->reg_host == (*rh)->reg_host))
    {
      GNUNET_free(*rh);
      *rh = rh_val;
      return GNUNET_NO;
    }
  return GNUNET_YES;
}


static struct GNUNET_HashCode
hash_hosts(struct GNUNET_TESTBED_Host *reg_host,
           struct GNUNET_TESTBED_Host *host)
{
  struct GNUNET_HashCode hash;
  uint32_t host_ids[2];

  host_ids[0] = GNUNET_TESTBED_host_get_id_(reg_host);
  host_ids[1] = GNUNET_TESTBED_host_get_id_(host);
  GNUNET_CRYPTO_hash(host_ids, sizeof(host_ids), &hash);
  return hash;
}


static struct RegisteredHostContext *
register_host(struct Slave *slave,
              struct GNUNET_TESTBED_Host *host)
{
  struct GNUNET_HashCode hash;
  struct RegisteredHostContext *rhc;

  rhc = GNUNET_new(struct RegisteredHostContext);
  rhc->reg_host = host;
  rhc->host = GST_host_list[slave->host_id];
  GNUNET_assert(NULL != rhc->reg_host);
  GNUNET_assert(NULL != rhc->host);
  rhc->state = RHC_INIT;
  hash = hash_hosts(rhc->reg_host, rhc->host);
  if ((GNUNET_NO ==
       GNUNET_CONTAINER_multihashmap_contains(slave->reghost_map,
                                              &hash)) ||
      (GNUNET_SYSERR !=
       GNUNET_CONTAINER_multihashmap_get_multiple(slave->reghost_map,
                                                  &hash,
                                                  reghost_match_iterator,
                                                  &rhc)))
    {
      /* create and add a new registerd host context */
      /* add the focc to its queue */
      GNUNET_CONTAINER_multihashmap_put(slave->reghost_map,
                                        &hash,
                                        rhc,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
      GST_queue_host_registration(slave,
                                  host_registration_comp,
                                  rhc,
                                  rhc->reg_host);
    }
  else
    {
      /* rhc is now set to the existing one from the hash map by
       * reghost_match_iterator() */
      /* if queue is empty then ignore creating focc and proceed with normal
       * forwarding */
      if (RHC_DONE == rhc->state)
        return NULL;
    }
  return rhc;
}


static void
forward_overlay_connect(const struct GNUNET_TESTBED_OverlayConnectMessage *msg,
                        struct GNUNET_SERVICE_Client *client)
{
  struct ForwardedOperationContext *fopc;
  struct Route *route_to_peer2_host;
  struct Route *route_to_peer1_host;
  struct Peer *peer;
  struct RegisteredHostContext *rhc;
  struct ForwardedOverlayConnectContext *focc;
  uint64_t op_id;
  uint32_t peer2_host_id;
  uint32_t p1;
  uint32_t p2;

  p1 = ntohl(msg->peer1);
  p2 = ntohl(msg->peer2);
  op_id = GNUNET_ntohll(msg->operation_id);
  peer2_host_id = ntohl(msg->peer2_host_id);
  GNUNET_assert(VALID_PEER_ID(p1));
  GNUNET_assert(VALID_HOST_ID(peer2_host_id));
  peer = GST_peer_list[p1];
  GNUNET_assert(GNUNET_YES == peer->is_remote);
  LOG_DEBUG("0x%llx: Forwarding overlay connect\n", op_id);
  route_to_peer2_host = GST_find_dest_route(peer2_host_id);
  route_to_peer1_host = GST_find_dest_route
                          (peer->details.remote.remote_host_id);
  GNUNET_assert(NULL != route_to_peer1_host);
  if ((NULL != route_to_peer2_host) &&
      (route_to_peer1_host->dest == route_to_peer2_host->dest))
    goto forward;
  /* Peer2 is either with us OR peer1 and peer2 can be reached through
     different subtrees OR peer2 is on a subtree unknown to us */
  if (NULL != (rhc = register_host(peer->details.remote.slave,
                                   GST_host_list[peer2_host_id])))
    {
      LOG_DEBUG("Queueing forwarding FOCC for connecting peers %u and %u\n", p1, p2);
      focc = GNUNET_new(struct ForwardedOverlayConnectContext);
      focc->rhc = rhc;
      focc->peer1 = p1;
      focc->peer2 = p2;
      focc->peer2_host_id = peer2_host_id;
      focc->orig_msg = GNUNET_copy_message(&msg->header);
      focc->operation_id = op_id;
      focc->client = client;
      GNUNET_CONTAINER_DLL_insert_tail(rhc->focc_dll_head,
                                       rhc->focc_dll_tail,
                                       focc);
      return;
    }

forward:
  LOG_DEBUG("Forwarding without FOCC for connecting peers %u and %u\n", p1, p2);
  fopc = GNUNET_new(struct ForwardedOperationContext);
  fopc->client = client;
  fopc->operation_id = op_id;
  fopc->type = OP_OVERLAY_CONNECT;
  fopc->opc =
    GNUNET_TESTBED_forward_operation_msg_(peer->details.remote.
                                          slave->controller, op_id,
                                          &msg->header,
                                          &GST_forwarded_operation_reply_relay,
                                          fopc);
  fopc->timeout_task =
    GNUNET_SCHEDULER_add_delayed(GST_timeout,
                                 &GST_forwarded_operation_timeout,
                                 fopc);
  GNUNET_CONTAINER_DLL_insert_tail(fopcq_head,
                                   fopcq_tail,
                                   fopc);
}


static void
p2_controller_connect_cb(void *cls,
                         struct GNUNET_TESTBED_Controller *c)
{
  struct OverlayConnectContext *occ = cls;
  struct RemotePeer2Context *rp2c;
  struct GNUNET_TESTBED_PeerGetConfigurationMessage cmsg;

  GNUNET_assert(OCC_TYPE_LOCAL != occ->type);
  rp2c = &occ->p2ctx.remote;
  rp2c->ncn = NULL;
  rp2c->p2c = c;
  cmsg.header.size =
    htons(sizeof(struct GNUNET_TESTBED_PeerGetConfigurationMessage));
  cmsg.header.type =
    htons(GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION);
  cmsg.peer_id = htonl(occ->other_peer_id);
  cmsg.operation_id = GNUNET_htonll(occ->op_id);
  rp2c->opc =
    GNUNET_TESTBED_forward_operation_msg_(rp2c->p2c,
                                          occ->op_id,
                                          &cmsg.header,
                                          &overlay_connect_get_config,
                                          occ);
  GNUNET_free_non_null(occ->emsg);
  GNUNET_asprintf(&occ->emsg,
                  "0x%llx: Timeout while getting peer identity of peer "
                  "with id: %u",
                  occ->op_id,
                  occ->other_peer_id);
}


void
handle_overlay_connect(void *cls,
                       const struct GNUNET_TESTBED_OverlayConnectMessage *msg)
{
  struct GNUNET_SERVICE_Client *client = cls;
  struct Peer *peer;
  struct Peer *peer2;
  struct OverlayConnectContext *occ;
  struct Neighbour *p2n;
  uint64_t operation_id;
  uint32_t p1;
  uint32_t p2;
  uint32_t peer2_host_id;

  p1 = ntohl(msg->peer1);
  p2 = ntohl(msg->peer2);
  if (!VALID_PEER_ID(p1))
    {
      GNUNET_break(0);
      GNUNET_SERVICE_client_drop(client);
      return;
    }
  peer = GST_peer_list[p1];
  operation_id = GNUNET_ntohll(msg->operation_id);
  LOG_DEBUG
    ("Received overlay connect for peers %u and %u with op id: 0x%llx\n",
    p1,
    p2,
    operation_id);
  peer2_host_id = ntohl(msg->peer2_host_id);
  if (GNUNET_YES == peer->is_remote)
    {
      if (!VALID_HOST_ID(peer2_host_id))
        {
          GNUNET_break(0);
          GNUNET_SERVICE_client_drop(client);
          return;
        }
      forward_overlay_connect(msg, client);
      GNUNET_SERVICE_client_continue(client);
      return;
    }
  p2n = NULL;
  occ = GNUNET_new(struct OverlayConnectContext);
  occ->type = OCC_TYPE_LOCAL;
  if (!VALID_PEER_ID(p2))         /* May be peer2 is on a another controller */
    {
      if (NULL == (p2n = GST_get_neighbour(peer2_host_id)))
        {
          if (!VALID_HOST_ID(peer2_host_id))
            {
              GNUNET_break(0);
              LOG(GNUNET_ERROR_TYPE_WARNING,
                  "0x%llx: Peer %u's host not in our neighbours list\n",
                  operation_id, p2);
              GNUNET_SERVICE_client_drop(client);
              GNUNET_free(occ);
              return;
            }
          p2n = GST_create_neighbour(GST_host_list[peer2_host_id]);
        }
      occ->type = OCC_TYPE_REMOTE_LATERAL;
      occ->p2ctx.remote.p2n = p2n;
    }
  else if (GNUNET_YES == GST_peer_list[p2]->is_remote)
    {
      occ->type = OCC_TYPE_REMOTE_SLAVE;
      occ->p2ctx.remote.p2c = GST_peer_list[p2]->details.remote.slave->controller;
    }
  GNUNET_CONTAINER_DLL_insert_tail(occq_head,
                                   occq_tail,
                                   occ);
  occ->client = client;
  occ->other_peer_id = p2;
  GST_peer_list[p1]->reference_cnt++;
  occ->peer = GST_peer_list[p1];
  occ->op_id = operation_id;
  GNUNET_assert(NULL == occ->timeout_task);
  occ->timeout_task =
    GNUNET_SCHEDULER_add_delayed(GST_timeout,
                                 &timeout_overlay_connect,
                                 occ);
  switch (occ->type)
    {
    case OCC_TYPE_REMOTE_LATERAL:
      GNUNET_asprintf(&occ->emsg,
                      "0x%llx: Timeout while acquiring connection to peer %u's "
                      "host: %u\n",
                      occ->op_id,
                      occ->other_peer_id,
                      peer2_host_id);
      occ->p2ctx.remote.ncn
        = GST_neighbour_get_connection(p2n,
                                       &p2_controller_connect_cb,
                                       occ);
      break;

    case OCC_TYPE_REMOTE_SLAVE:
      p2_controller_connect_cb(occ,
                               occ->p2ctx.remote.p2c);
      break;

    case OCC_TYPE_LOCAL:
      peer2 = GST_peer_list[occ->other_peer_id];
      peer2->reference_cnt++;
      GNUNET_TESTING_peer_get_identity(peer2->details.local.peer,
                                       &occ->other_peer_identity);
      GNUNET_asprintf(&occ->emsg,
                      "0x%llx: Timeout while connecting to CORE of peer with "
                      "id: %u",
                      occ->op_id,
                      occ->peer->id);
      occ->cgh_ch =
        GST_connection_pool_get_handle(occ->peer->id,
                                       occ->peer->details.local.cfg,
                                       GST_CONNECTIONPOOL_SERVICE_CORE,
                                       occ_cache_get_handle_core_cb, occ,
                                       &occ->other_peer_identity,
                                       &overlay_connect_notify, occ);
      break;
    }
  GNUNET_SERVICE_client_continue(client);
}


static void
cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
{
  LOG_DEBUG("0x%llx: Cleaning up rocc\n",
            rocc->op_id);
  if (NULL != rocc->attempt_connect_task_id)
    GNUNET_SCHEDULER_cancel(rocc->attempt_connect_task_id);
  if (NULL != rocc->timeout_rocc_task_id)
    GNUNET_SCHEDULER_cancel(rocc->timeout_rocc_task_id);
  if (NULL != rocc->ohh)
    GNUNET_TRANSPORT_offer_hello_cancel(rocc->ohh);
  if (NULL != rocc->tcc.csh)
    GNUNET_ATS_connectivity_suggest_cancel(rocc->tcc.csh);
  GST_connection_pool_get_handle_done(rocc->tcc.cgh_p2_th);
  GST_connection_pool_get_handle_done(rocc->tcc.cgh_p2_ats);
  GNUNET_assert(rocc->peer->reference_cnt > 0);
  rocc->peer->reference_cnt--;
  if ((GNUNET_YES == rocc->peer->destroy_flag) &&
      (0 == rocc->peer->reference_cnt))
    GST_destroy_peer(rocc->peer);
  GNUNET_free_non_null(rocc->hello);
  GNUNET_CONTAINER_DLL_remove(roccq_head,
                              roccq_tail,
                              rocc);
  GNUNET_free(rocc);
}


static void
timeout_rocc_task(void *cls)
{
  struct RemoteOverlayConnectCtx *rocc = cls;

  GNUNET_assert(rocc->timeout_rocc_task_id != NULL);
  rocc->timeout_rocc_task_id = NULL;
  LOG_DEBUG("0x%llx: rocc timed out\n",
            rocc->op_id);
  cleanup_rocc(rocc);
}


static void
cache_transport_peer_connect_notify(void *cls,
                                    const struct GNUNET_PeerIdentity *new_peer)
{
  struct RemoteOverlayConnectCtx *rocc = cls;

  LOG_DEBUG("0x%llx: Request Overlay connect notify\n",
            rocc->op_id);
  GNUNET_assert(0 ==
                memcmp(new_peer, &rocc->a_id,
                       sizeof(struct GNUNET_PeerIdentity)));
  LOG_DEBUG("0x%llx: Peer %s connected\n",
            rocc->op_id,
            GNUNET_i2s(&rocc->a_id));
  cleanup_rocc(rocc);
}


static void
attempt_connect_task(void *cls);


static void
rocc_hello_sent_cb(void *cls)
{
  struct RemoteOverlayConnectCtx *rocc = cls;

  rocc->ohh = NULL;
  GNUNET_assert(NULL == rocc->attempt_connect_task_id);
  LOG_DEBUG("0x%llx: HELLO of peer %s delivered to local peer with id: %u\n",
            rocc->op_id,
            GNUNET_i2s(&rocc->a_id),
            rocc->peer->id);
  rocc->tcc.cgh_p2_ats =
    GST_connection_pool_get_handle(rocc->peer->id,
                                   rocc->peer->details.local.cfg,
                                   GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY,
                                   &occ_cache_get_handle_ats_rocc_cb,
                                   rocc, NULL, NULL, NULL);
}


static void
attempt_connect_task(void *cls)
{
  struct RemoteOverlayConnectCtx *rocc = cls;

  GNUNET_assert(NULL != rocc->attempt_connect_task_id);
  rocc->attempt_connect_task_id = NULL;
  LOG_DEBUG("0x%llx: Offering HELLO of peer %s to remote peer with id: %u\n",
            rocc->op_id,
            GNUNET_i2s(&rocc->a_id),
            rocc->peer->id);
  rocc->ohh =
    GNUNET_TRANSPORT_offer_hello(rocc->tcc.cfg,
                                 rocc->hello,
                                 &rocc_hello_sent_cb,
                                 rocc);
  if (NULL == rocc->ohh)
    rocc->attempt_connect_task_id =
      GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply
                                     (GNUNET_TIME_UNIT_MILLISECONDS,
                                     100 +
                                     GNUNET_CRYPTO_random_u32
                                       (GNUNET_CRYPTO_QUALITY_WEAK, 500)),
                                   &attempt_connect_task, rocc);
}


static void
rocc_cache_get_handle_transport_cb(void *cls,
                                   struct GNUNET_CORE_Handle *ch,
                                   struct GNUNET_TRANSPORT_CoreHandle *th,
                                   struct GNUNET_ATS_ConnectivityHandle *ac,
                                   const struct GNUNET_PeerIdentity *ignore_,
                                   const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct RemoteOverlayConnectCtx *rocc = cls;

  if (NULL == th)
    {
      rocc->timeout_rocc_task_id =
        GNUNET_SCHEDULER_add_now(&timeout_rocc_task, rocc);
      return;
    }
  rocc->tcc.th_ = th;
  rocc->tcc.cfg = cfg;
  if (NULL !=
      GNUNET_TRANSPORT_core_get_mq(rocc->tcc.th_,
                                   &rocc->a_id))
    {
      LOG_DEBUG("0x%llx: Target peer %s already connected to local peer: %u\n",
                rocc->op_id,
                GNUNET_i2s(&rocc->a_id),
                rocc->peer->id);
      cleanup_rocc(rocc);
      return;
    }
  rocc->attempt_connect_task_id =
    GNUNET_SCHEDULER_add_now(&attempt_connect_task, rocc);
}


int
check_remote_overlay_connect(void *cls,
                             const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
{
  uint32_t peer_id;
  uint16_t msize;
  uint16_t hsize;

  msize = ntohs(msg->header.size);
  if (GNUNET_MESSAGE_TYPE_HELLO != ntohs(msg->hello->type))
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  hsize = ntohs(msg->hello->size);
  if ((sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) != msize)
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  peer_id = ntohl(msg->peer);
  if ((peer_id >= GST_peer_list_size) ||
      (NULL == GST_peer_list[peer_id]))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}


void
handle_remote_overlay_connect(void *cls,
                              const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
{
  struct GNUNET_SERVICE_Client *client = cls;
  struct RemoteOverlayConnectCtx *rocc;
  struct Peer *peer;
  struct GNUNET_PeerIdentity pid;
  static char pid_str[16];
  uint32_t peer_id;
  uint16_t hsize;

  hsize = ntohs(msg->hello->size);
  peer_id = ntohl(msg->peer);
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
    {
      struct GNUNET_MessageHeader *msg2;

      msg2 = GNUNET_copy_message(&msg->header);
      GNUNET_TESTBED_queue_message_(peer->details.remote.slave->controller,
                                    msg2);
      GNUNET_SERVICE_client_continue(client);
      return;
    }
  rocc = GNUNET_new(struct RemoteOverlayConnectCtx);
  rocc->op_id = GNUNET_ntohll(msg->operation_id);
  GNUNET_CONTAINER_DLL_insert_tail(roccq_head,
                                   roccq_tail,
                                   rocc);
  rocc->a_id = msg->peer_identity;
  GNUNET_TESTING_peer_get_identity(peer->details.local.peer,
                                   &pid);
  (void)GNUNET_strlcpy(pid_str,
                       GNUNET_i2s(&pid),
                       sizeof(pid_str));
  LOG_DEBUG("0x%llx: Remote overlay connect %s to peer %s with hello size: %u\n",
            rocc->op_id,
            pid_str,
            GNUNET_i2s(&rocc->a_id),
            hsize);
  rocc->peer = peer;
  rocc->peer->reference_cnt++;
  rocc->hello = GNUNET_malloc(hsize);
  GNUNET_memcpy(rocc->hello,
                msg->hello,
                hsize);
  rocc->tcc.cgh_p2_th =
    GST_connection_pool_get_handle(peer_id,
                                   rocc->peer->details.local.cfg,
                                   GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
                                   &rocc_cache_get_handle_transport_cb,
                                   rocc,
                                   &rocc->a_id,
                                   &cache_transport_peer_connect_notify,
                                   rocc);
  rocc->timeout_rocc_task_id =
    GNUNET_SCHEDULER_add_delayed(GST_timeout,
                                 &timeout_rocc_task,
                                 rocc);
  GNUNET_SERVICE_client_continue(client);
}


void
GST_free_occq()
{
  struct OverlayConnectContext *occ;

  while (NULL != (occ = occq_head))
    cleanup_occ(occ);
}


void
GST_free_roccq()
{
  struct RemoteOverlayConnectCtx *rocc;

  while (NULL != (rocc = roccq_head))
    cleanup_rocc(rocc);
}