/* This file is part of GNUnet. (C) 2012 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, 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 General Public License for more details. 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. */ /** * @file testbed/gnunet-service-testbed_oc.c * @brief code for handling overlay connect operations * @author Sree Harsha Totakura */ #include "gnunet-service-testbed.h" /** * Redefine LOG with a changed log component string */ #ifdef LOG #undef LOG #endif #define LOG(kind,...) \ GNUNET_log_from (kind, "testbed-OC", __VA_ARGS__) /** * Context information for requesting TRANSPORT to connect to a peer */ struct TryConnectContext { /** * The identity of the peer to which the transport has to attempt a connection */ struct GNUNET_PeerIdentity *pid; /** * The transport handle obtained from cache. Do NOT close/disconnect. */ struct GNUNET_TRANSPORT_Handle *th_; /** * The GetCacheHandle for the p1th transport handle */ struct GSTCacheGetHandle *cgh_th; /** * the try connect handle */ struct GNUNET_TRANSPORT_TryConnectHandle *tch; /** * The task handle */ GNUNET_SCHEDULER_TaskIdentifier task; /** * The id of the operation which is resposible for this context */ uint64_t op_id; /** * The number of times we attempted to connect */ unsigned int retries; }; /** * Context information for connecting 2 peers in overlay. */ struct OverlayConnectContext { /** * The next pointer for maintaining a DLL of all OverlayConnectContexts */ struct OverlayConnectContext *next; /** * The prev pointer for maintaining a DLL of all OverlayConnectContexts */ struct OverlayConnectContext *prev; /** * The client which has requested for overlay connection. This is used to send * either a success of failure message */ struct GNUNET_SERVER_Client *client; /** * the first peer which is to expect an overlay connection from the second peer. */ struct Peer *peer; /** * Transport handle of the first peer obtained from cache to get its HELLO. Do * NOT close/disconnect. */ struct GNUNET_TRANSPORT_Handle *p1th_; /** * The CacheGetHandle for the p1th transport handle */ struct GSTCacheGetHandle *cgh_p1th; /** * The GetCacheHandle for registering callback to notify CORE level peer * connects and to get our identity. */ struct GSTCacheGetHandle *cgh_ch; /** * HELLO of the first peer. This should be sent to the second peer. */ struct GNUNET_MessageHeader *hello; /** * Get GetHelloHandle to acquire a HELLO of the first peer */ struct GNUNET_TRANSPORT_GetHelloHandle *ghh; /** * The handle for offering the HELLO of the first peer to the second * peer. This is only used if the second peer is a local peer. */ struct GNUNET_TRANSPORT_OfferHelloHandle *ohh; /** * The error message we send if this overlay connect operation has timed out */ char *emsg; /** * Operation context for the suboperation we start to get the identity of the * second peer if it is a remote peer */ struct OperationContext *opc; /** * Controller of peer 2; NULL if the peer is a local peer */ struct GNUNET_TESTBED_Controller *peer2_controller; /** * The transport TryConnectContext. This will be NULL if the second peer is a * remote peer */ struct TryConnectContext tcc; /** * The peer identity of the first peer */ struct GNUNET_PeerIdentity peer_identity; /** * The peer identity of the other peer */ struct GNUNET_PeerIdentity other_peer_identity; /** * The id of the operation responsible for creating this context */ uint64_t op_id; /** * The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to * connect to peer 2 */ GNUNET_SCHEDULER_TaskIdentifier send_hello_task; /** * The id of the overlay connect timeout task */ GNUNET_SCHEDULER_TaskIdentifier timeout_task; /** * The id of the cleanup task */ GNUNET_SCHEDULER_TaskIdentifier cleanup_task; /** * The id of peer A */ uint32_t peer_id; /** * The id of peer B */ uint32_t other_peer_id; }; /** * Context information for remote overlay connect operations. Remote overlay * connections are used when peers A and B reside on different hosts. In these * operations the host controller for peer B is asked by the host controller of * peer A to make peer B connect to peer A by sending the controller of peer B * the HELLO of peer A. */ struct RemoteOverlayConnectCtx { /** * the next pointer for DLL */ struct RemoteOverlayConnectCtx *next; /** * the prev pointer for DLL */ struct RemoteOverlayConnectCtx *prev; /** * The peer handle of peer B */ struct Peer *peer; /** * Peer A's HELLO */ struct GNUNET_MessageHeader *hello; /** * The handle for offering HELLO */ struct GNUNET_TRANSPORT_OfferHelloHandle *ohh; /** * The transport try connect context */ struct TryConnectContext tcc; /** * The peer identity of peer A */ struct GNUNET_PeerIdentity a_id; /** * Task for offering HELLO of A to B and doing try_connect */ GNUNET_SCHEDULER_TaskIdentifier attempt_connect_task_id; /** * Task to timeout RequestOverlayConnect */ GNUNET_SCHEDULER_TaskIdentifier timeout_rocc_task_id; /** * The id of the operation responsible for creating this context */ uint64_t op_id; }; /** * DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown */ static struct OverlayConnectContext *occq_head; /** * DLL tail for OverlayConnectContext DLL */ static struct OverlayConnectContext *occq_tail; /** * DLL head for RequectOverlayConnectContext DLL - to be used to clean up during * shutdown */ static struct RemoteOverlayConnectCtx *roccq_head; /** * DLL tail for RequectOverlayConnectContext DLL */ static struct RemoteOverlayConnectCtx *roccq_tail; /** * Cleans up ForwardedOverlayConnectContext * * @param focc the ForwardedOverlayConnectContext to cleanup */ void GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc) { GNUNET_free_non_null (focc->orig_msg); GNUNET_free (focc); } /** * Timeout task for cancelling a forwarded overlay connect connect * * @param cls the ForwardedOverlayConnectContext * @param tc the task context from the scheduler */ static void forwarded_overlay_connect_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct ForwardedOperationContext *fopc = cls; struct RegisteredHostContext *rhc; struct ForwardedOverlayConnectContext *focc; rhc = fopc->cls; focc = rhc->focc_dll_head; GNUNET_CONTAINER_DLL_remove (rhc->focc_dll_head, rhc->focc_dll_tail, focc); GST_cleanup_focc (focc); LOG_DEBUG ("Overlay linking between peers %u and %u failed\n", focc->peer1, focc->peer2); GST_forwarded_operation_timeout (cls, tc); if (NULL != rhc->focc_dll_head) GST_process_next_focc (rhc); } /** * Callback to be called when forwarded overlay connection operation has a reply * from the sub-controller successfull. We have to relay the reply msg back to * the client * * @param cls ForwardedOperationContext * @param msg the peer create success message */ 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; GNUNET_CONTAINER_DLL_remove (rhc->focc_dll_head, rhc->focc_dll_tail, focc); GST_cleanup_focc (focc); if (NULL != rhc->focc_dll_head) GST_process_next_focc (rhc); } /** * Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext * * @param rhc the RegisteredHostContext */ void GST_process_next_focc (struct RegisteredHostContext *rhc) { struct ForwardedOperationContext *fopc; struct ForwardedOverlayConnectContext *focc; focc = rhc->focc_dll_head; GNUNET_assert (NULL != focc); GNUNET_assert (RHC_OL_CONNECT == rhc->state); fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext)); GNUNET_SERVER_client_keep (rhc->client); fopc->client = rhc->client; fopc->operation_id = focc->operation_id; fopc->cls = rhc; fopc->type = OP_OVERLAY_CONNECT; fopc->opc = GNUNET_TESTBED_forward_operation_msg_ (rhc->gateway->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 (TIMEOUT, &forwarded_overlay_connect_timeout, fopc); GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc); } /** * Cleanup overlay connect context structure * * @param occ the overlay connect context */ static void cleanup_occ (struct OverlayConnectContext *occ) { LOG_DEBUG ("0x%llx: Cleaning up occ\n", occ->op_id); GNUNET_free_non_null (occ->emsg); GNUNET_free_non_null (occ->hello); GNUNET_SERVER_client_drop (occ->client); if (NULL != occ->opc) GNUNET_TESTBED_forward_operation_msg_cancel_ (occ->opc); if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task) GNUNET_SCHEDULER_cancel (occ->send_hello_task); if (GNUNET_SCHEDULER_NO_TASK != occ->cleanup_task) GNUNET_SCHEDULER_cancel (occ->cleanup_task); if (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task) GNUNET_SCHEDULER_cancel (occ->timeout_task); if (NULL != occ->cgh_ch) { GST_cache_get_handle_done (occ->cgh_ch); occ->peer->reference_cnt--; } if (NULL != occ->ghh) GNUNET_TRANSPORT_get_hello_cancel (occ->ghh); if (NULL != occ->ohh) GNUNET_TRANSPORT_offer_hello_cancel (occ->ohh); if (GNUNET_SCHEDULER_NO_TASK != occ->tcc.task) GNUNET_SCHEDULER_cancel (occ->tcc.task); if (NULL != occ->tcc.tch) GNUNET_TRANSPORT_try_connect_cancel (occ->tcc.tch); if (NULL != occ->cgh_p1th) { GST_cache_get_handle_done (occ->cgh_p1th); occ->peer->reference_cnt--; } if (NULL != occ->tcc.cgh_th) { GST_cache_get_handle_done (occ->tcc.cgh_th); GST_peer_list[occ->other_peer_id]->reference_cnt--; } if ((GNUNET_YES == occ->peer->destroy_flag) && (0 == occ->peer->reference_cnt)) GST_destroy_peer (occ->peer); if ((NULL == occ->peer2_controller) && (GNUNET_YES == GST_peer_list[occ->other_peer_id]->destroy_flag) && (0 == GST_peer_list[occ->other_peer_id]->reference_cnt)) GST_destroy_peer (GST_peer_list[occ->other_peer_id]); GNUNET_CONTAINER_DLL_remove (occq_head, occq_tail, occ); GNUNET_free (occ); } /** * Task for cleaing up overlay connect context structure * * @param cls the overlay connect context * @param tc the task context */ static void do_cleanup_occ (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct OverlayConnectContext *occ = cls; occ->cleanup_task = GNUNET_SCHEDULER_NO_TASK; cleanup_occ (occ); } /** * Task which will be run when overlay connect request has been timed out * * @param cls the OverlayConnectContext * @param tc the TaskContext */ static void timeout_overlay_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct OverlayConnectContext *occ = cls; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); occ->timeout_task = GNUNET_SCHEDULER_NO_TASK; LOG (GNUNET_ERROR_TYPE_WARNING, "0x%llx: Timeout while connecting peers %u and %u\n", occ->op_id, occ->peer_id, occ->other_peer_id); GST_send_operation_fail_msg (occ->client, occ->op_id, occ->emsg); cleanup_occ (occ); } static void send_overlay_connect_success_msg (struct OverlayConnectContext *occ) { struct GNUNET_TESTBED_ConnectionEventMessage *msg; LOG_DEBUG ("0x%llx: Peers connected - Sending overlay connect success\n", occ->op_id); msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage)); msg->header.size = htons (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage)); msg->header.type = htons (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); GST_queue_message (occ->client, &msg->header); } /** * Function called to notify transport users that another * peer connected to us. * * @param cls closure * @param new_peer the peer that connected */ 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 %4s connected when expecting peer %4s\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 %4s connected to peer %4s\n", occ->op_id, other_peer_str, GNUNET_i2s (&occ->peer_identity)); GNUNET_free (other_peer_str); if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task) { GNUNET_SCHEDULER_cancel (occ->send_hello_task); occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK; } GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); GNUNET_SCHEDULER_cancel (occ->timeout_task); occ->timeout_task = GNUNET_SCHEDULER_NO_TASK; if (GNUNET_SCHEDULER_NO_TASK != occ->tcc.task) { GNUNET_SCHEDULER_cancel (occ->tcc.task); occ->tcc.task = GNUNET_SCHEDULER_NO_TASK; } 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); //cleanup_occ (occ); } /** * Task to ask transport of a peer to connect to another peer * * @param cls the TryConnectContext * @param tc the scheduler task context */ static void try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); /** * Callback to be called with result of the try connect request. * * @param cls the overlay connect context * @param result GNUNET_OK if message was transmitted to transport service * GNUNET_SYSERR if message was not transmitted to transport service */ static void try_connect_cb (void *cls, const int result) { struct TryConnectContext *tcc = cls; tcc->tch = NULL; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == tcc->task); tcc->task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500 + pow (2, ++tcc->retries)), &try_connect_task, tcc); } /** * Task to ask transport of a peer to connect to another peer * * @param cls the TryConnectContext * @param tc the scheduler task context */ static void try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct TryConnectContext *tcc = cls; tcc->task = GNUNET_SCHEDULER_NO_TASK; if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) return; GNUNET_assert (NULL == tcc->tch); GNUNET_assert (NULL != tcc->pid); GNUNET_assert (NULL != tcc->th_); GNUNET_assert (NULL != tcc->cgh_th); LOG_DEBUG ("0x%llx: Trail %u to connect to peer %s\n", tcc->op_id, tcc->retries, GNUNET_i2s (tcc->pid)); tcc->tch = GNUNET_TRANSPORT_try_connect (tcc->th_, tcc->pid, &try_connect_cb, tcc); } /** * Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to * peer 1. * * @param cls the OverlayConnectContext * @param tc the TaskContext from scheduler */ static void send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); /** * Task that is run when hello has been sent * * @param cls the overlay connect context * @param tc the scheduler task context; if tc->reason = * GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if * GNUNET_SCHEDULER_REASON_READ_READY is succeeded */ static void occ_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct OverlayConnectContext *occ = cls; occ->ohh = NULL; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->send_hello_task); if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason) { GNUNET_free_non_null (occ->emsg); GNUNET_asprintf (&occ->emsg, "0x%llx: Timeout while offering HELLO to other peer", occ->op_id); occ->send_hello_task = GNUNET_SCHEDULER_add_now (&send_hello, occ); return; } if (GNUNET_SCHEDULER_REASON_READ_READY != tc->reason) return; GNUNET_free_non_null (occ->emsg); GNUNET_asprintf (&occ->emsg, "0x%llx: Timeout while try connect", occ->op_id); occ->tcc.pid = &occ->peer_identity; occ->tcc.op_id = occ->op_id; occ->tcc.task = GNUNET_SCHEDULER_add_now (&try_connect_task, &occ->tcc); } /** * Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to * peer 1. * * @param cls the OverlayConnectContext * @param tc the TaskContext from scheduler */ static void send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct OverlayConnectContext *occ = cls; char *other_peer_str; occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK; if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) return; GNUNET_assert (NULL != occ->hello); other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity)); if (NULL != occ->peer2_controller) { struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg; uint16_t msize; uint16_t hello_size; 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); 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); (void) memcpy (&msg->peer_identity, &occ->peer_identity, sizeof (struct GNUNET_PeerIdentity)); memcpy (msg->hello, occ->hello, hello_size); GNUNET_TESTBED_queue_message_ (occ->peer2_controller, &msg->header); } else { LOG_DEBUG ("0x%llx: Offering HELLO of %s to %s\n", occ->op_id, GNUNET_i2s (&occ->peer_identity), other_peer_str); occ->ohh = GNUNET_TRANSPORT_offer_hello (occ->tcc.th_, occ->hello, occ_hello_sent_cb, occ); if (NULL == occ->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); } } GNUNET_free (other_peer_str); } /** * Callback from cache with needed handles set * * @param cls the closure passed to GST_cache_get_handle_transport() * @param ch the handle to CORE. Can be NULL if it is not requested * @param th the handle to TRANSPORT. Can be NULL if it is not requested * @param ignore_ peer identity which is ignored in this callback */ static void p2_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_Handle *th, const struct GNUNET_PeerIdentity *ignore_) { struct OverlayConnectContext *occ = cls; 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->tcc.th_ = th; 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); } /** * Connects to the transport of the other peer if it is a local peer and * schedules the send hello task * * @param occ the overlay connect context */ static void p2_transport_connect (struct OverlayConnectContext *occ) { 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 (NULL == occ->peer2_controller) { GST_peer_list[occ->other_peer_id]->reference_cnt++; occ->tcc.cgh_th = GST_cache_get_handle_transport (occ->other_peer_id, GST_peer_list[occ->other_peer_id]-> details.local.cfg, &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); } /** * Test for checking whether HELLO message is empty * * @param cls empty flag to set * @param address the HELLO * @param expiration expiration of the HELLO * @return */ 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; } /** * Function called whenever there is an update to the HELLO of peers in the * OverlayConnectClosure. If we have a valid HELLO, we connect to the peer 2's * transport and offer peer 1's HELLO and ask peer 2 to connect to peer 1 * * @param cls closure * @param hello our updated HELLO */ 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); memcpy (occ->hello, hello, msize); GNUNET_TRANSPORT_get_hello_cancel (occ->ghh); occ->ghh = NULL; GST_cache_get_handle_done (occ->cgh_p1th); occ->peer->reference_cnt--; occ->cgh_p1th = NULL; occ->p1th_ = NULL; GNUNET_free_non_null (occ->emsg); occ->emsg = NULL; p2_transport_connect (occ); } /** * Callback from cache with needed handles set * * @param cls the closure passed to GST_cache_get_handle_transport() * @param ch the handle to CORE. Can be NULL if it is not requested * @param th the handle to TRANSPORT. Can be NULL if it is not requested * @param ignore_ peer identity which is ignored in this callback */ static void p1_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_Handle *th, const struct GNUNET_PeerIdentity *ignore_) { 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 %4s", occ->op_id, GNUNET_i2s (&occ->peer_identity)); occ->ghh = GNUNET_TRANSPORT_get_hello (occ->p1th_, &hello_update_cb, occ); } /** * Callback from cache with needed handles set * * @param cls the closure passed to GST_cache_get_handle_transport() * @param ch the handle to CORE. Can be NULL if it is not requested * @param th the handle to TRANSPORT. Can be NULL if it is not requested * @param my_identity the identity of our peer */ static void occ_cache_get_handle_core_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_Handle *th, const struct GNUNET_PeerIdentity *my_identity) { struct OverlayConnectContext *occ = cls; const struct GNUNET_MessageHeader *hello; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); GNUNET_free_non_null (occ->emsg); if ((NULL == ch) || (NULL == my_identity)) { (void) 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->ch_ = ch; occ->emsg = NULL; if (GNUNET_YES == GNUNET_CORE_is_peer_connected_sync (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 = GNUNET_SCHEDULER_NO_TASK; send_overlay_connect_success_msg (occ); occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ); return; } memcpy (&occ->peer_identity, my_identity, sizeof (struct GNUNET_PeerIdentity)); 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->peer->reference_cnt++; occ->cgh_p1th = GST_cache_get_handle_transport (occ->peer_id, occ->peer->details.local.cfg, p1_transport_connect_cache_callback, occ, NULL, NULL, NULL); return; } /** * Callback to be called when forwarded get peer config operation as part of * overlay connect is successfull. Connection to Peer 1's core is made and is * checked for new connection from peer 2 * * @param cls ForwardedOperationContext * @param msg the peer create success message */ static void overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg) { struct OverlayConnectContext *occ = cls; const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *cmsg; occ->opc = NULL; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONFIGURATION != 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; memcpy (&occ->other_peer_identity, &cmsg->peer_identity, sizeof (struct GNUNET_PeerIdentity)); 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->peer->reference_cnt++; occ->cgh_ch = GST_cache_get_handle_core (occ->peer_id, occ->peer->details.local.cfg, occ_cache_get_handle_core_cb, occ, &occ->other_peer_identity, &overlay_connect_notify, occ); return; } /** * Callback which will be called to after a host registration succeeded or failed * * @param cls the RegisteredHostContext * @param emsg the error message; NULL if host registration is successful */ static void registeredhost_registration_completion (void *cls, const char *emsg) { struct RegisteredHostContext *rhc = cls; struct GNUNET_CONFIGURATION_Handle *cfg; uint32_t peer2_host_id; /* if (NULL != rhc->focc_dll_head) */ /* TESTBED_process_next_focc (rhc); */ peer2_host_id = GNUNET_TESTBED_host_get_id_ (rhc->reg_host); GNUNET_assert (RHC_INIT == rhc->state); GNUNET_assert (NULL == rhc->sub_op); if ((NULL == rhc->gateway2) || ((peer2_host_id < GST_slave_list_size) /* Check if we have the needed config */ && (NULL != GST_slave_list[peer2_host_id]))) { rhc->state = RHC_LINK; cfg = (NULL == rhc->gateway2) ? our_config : GST_slave_list[peer2_host_id]->cfg; rhc->sub_op = GNUNET_TESTBED_controller_link (rhc, rhc->gateway->controller, rhc->reg_host, rhc->host, cfg, GNUNET_NO); return; } rhc->state = RHC_GET_CFG; rhc->sub_op = GNUNET_TESTBED_get_slave_config (rhc, rhc->gateway2->controller, rhc->reg_host); } /** * Iterator to match a registered host context * * @param cls pointer 2 pointer of RegisteredHostContext * @param key current key code * @param value value in the hash map * @return GNUNET_YES if we should continue to * iterate, * GNUNET_NO if not. */ static int 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; } /** * Function to generate the hashcode corresponding to a RegisteredHostContext * * @param reg_host the host which is being registered in RegisteredHostContext * @param host the host of the controller which has to connect to the above rhost * @return the hashcode */ 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; } /** * Handler for GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT messages * * @param cls NULL * @param client identification of the client * @param message the actual message */ void GST_handle_overlay_connect (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { const struct GNUNET_TESTBED_OverlayConnectMessage *msg; struct Peer *peer; struct OverlayConnectContext *occ; struct GNUNET_TESTBED_Controller *peer2_controller; uint64_t operation_id; uint32_t p1; uint32_t p2; uint32_t peer2_host_id; if (sizeof (struct GNUNET_TESTBED_OverlayConnectMessage) != ntohs (message->size)) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } msg = (const struct GNUNET_TESTBED_OverlayConnectMessage *) message; p1 = ntohl (msg->peer1); p2 = ntohl (msg->peer2); if ((p1 >= GST_peer_list_size) || (NULL == GST_peer_list[p1])) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } peer = GST_peer_list[p1]; peer2_host_id = ntohl (msg->peer2_host_id); 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); if (GNUNET_YES == peer->is_remote) { struct ForwardedOperationContext *fopc; struct Route *route_to_peer2_host; struct Route *route_to_peer1_host; LOG_DEBUG ("0x%llx: Forwarding overlay connect\n", operation_id); route_to_peer2_host = NULL; route_to_peer1_host = NULL; route_to_peer2_host = GST_find_dest_route (peer2_host_id); if ((NULL != route_to_peer2_host) || (peer2_host_id == GST_context->host_id)) { /* Peer 2 either below us OR with us */ route_to_peer1_host = GST_find_dest_route (GST_peer_list[p1]->details. remote.remote_host_id); /* Because we get this message only if we know where peer 1 is */ GNUNET_assert (NULL != route_to_peer1_host); if ((peer2_host_id == GST_context->host_id) || (route_to_peer2_host->dest != route_to_peer1_host->dest)) { /* Peer2 is either with us OR peer1 and peer2 can be reached through * different gateways */ struct GNUNET_HashCode hash; struct RegisteredHostContext *rhc; int skip_focc; rhc = GNUNET_malloc (sizeof (struct RegisteredHostContext)); if (NULL != route_to_peer2_host) rhc->reg_host = GST_host_list[route_to_peer2_host->dest]; else rhc->reg_host = GST_host_list[GST_context->host_id]; rhc->host = GST_host_list[route_to_peer1_host->dest]; GNUNET_assert (NULL != rhc->reg_host); GNUNET_assert (NULL != rhc->host); rhc->gateway = peer->details.remote.slave; rhc->gateway2 = (NULL == route_to_peer2_host) ? NULL : GST_slave_list[route_to_peer2_host->dest]; rhc->state = RHC_INIT; GNUNET_SERVER_client_keep (client); rhc->client = client; hash = hash_hosts (rhc->reg_host, rhc->host); skip_focc = GNUNET_NO; if ((GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (peer->details. remote.slave->reghost_map, &hash)) || (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple (peer->details.remote. 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 (peer->details.remote. slave->reghost_map, &hash, rhc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); GNUNET_assert (NULL != GST_host_list[peer2_host_id]); GST_queue_host_registration (peer->details.remote.slave, registeredhost_registration_completion, rhc, GST_host_list[peer2_host_id]); } 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_OL_CONNECT == rhc->state) skip_focc = GNUNET_YES; } if (GNUNET_NO == skip_focc) { struct ForwardedOverlayConnectContext *focc; focc = GNUNET_malloc (sizeof (struct ForwardedOverlayConnectContext)); focc->peer1 = p1; focc->peer2 = p2; focc->peer2_host_id = peer2_host_id; focc->orig_msg = GNUNET_copy_message (message); focc->operation_id = operation_id; GNUNET_CONTAINER_DLL_insert_tail (rhc->focc_dll_head, rhc->focc_dll_tail, focc); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } } } fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext)); GNUNET_SERVER_client_keep (client); fopc->client = client; fopc->operation_id = operation_id; fopc->type = OP_OVERLAY_CONNECT; fopc->opc = GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote. slave->controller, operation_id, message, &GST_forwarded_operation_reply_relay, fopc); fopc->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &GST_forwarded_operation_timeout, fopc); GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } peer2_controller = NULL; if ((p2 >= GST_peer_list_size) || (NULL == GST_peer_list[p2])) { if ((peer2_host_id >= GST_slave_list_size) || (NULL == GST_slave_list[peer2_host_id])) { LOG (GNUNET_ERROR_TYPE_WARNING, "0x%llx: Configuration of peer2's controller missing for connecting peers" "%u and %u\n", operation_id, p1, p2); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } peer2_controller = GST_slave_list[peer2_host_id]->controller; if (NULL == peer2_controller) { GNUNET_break (0); /* What's going on? */ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } } else { if (GNUNET_YES == GST_peer_list[p2]->is_remote) peer2_controller = GST_peer_list[p2]->details.remote.slave->controller; } occ = GNUNET_malloc (sizeof (struct OverlayConnectContext)); GNUNET_CONTAINER_DLL_insert_tail (occq_head, occq_tail, occ); GNUNET_SERVER_client_keep (client); occ->client = client; occ->peer_id = p1; occ->other_peer_id = p2; occ->peer = GST_peer_list[p1]; occ->op_id = GNUNET_ntohll (msg->operation_id); occ->peer2_controller = peer2_controller; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->timeout_task); occ->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_overlay_connect, occ); /* Get the identity of the second peer */ if (NULL != occ->peer2_controller) { struct GNUNET_TESTBED_PeerGetConfigurationMessage cmsg; cmsg.header.size = htons (sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage)); cmsg.header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_CONFIGURATION); cmsg.peer_id = msg->peer2; cmsg.operation_id = msg->operation_id; occ->opc = GNUNET_TESTBED_forward_operation_msg_ (occ->peer2_controller, occ->op_id, &cmsg.header, &overlay_connect_get_config, occ); GNUNET_asprintf (&occ->emsg, "0x%llx: Timeout while getting peer identity of peer " "with id: %u", occ->op_id, occ->other_peer_id); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } GNUNET_TESTING_peer_get_identity (GST_peer_list[occ->other_peer_id]-> 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->peer->reference_cnt++; occ->cgh_ch = GST_cache_get_handle_core (occ->peer_id, occ->peer->details.local.cfg, occ_cache_get_handle_core_cb, occ, &occ->other_peer_identity, &overlay_connect_notify, occ); GNUNET_SERVER_receive_done (client, GNUNET_OK); } /** * Function to cleanup RemoteOverlayConnectCtx and any associated tasks * with it * * @param rocc the RemoteOverlayConnectCtx */ static void cleanup_rocc (struct RemoteOverlayConnectCtx *rocc) { LOG_DEBUG ("0x%llx: Cleaning up rocc\n", rocc->op_id); if (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id) GNUNET_SCHEDULER_cancel (rocc->attempt_connect_task_id); if (GNUNET_SCHEDULER_NO_TASK != 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.tch) GNUNET_TRANSPORT_try_connect_cancel (rocc->tcc.tch); if (GNUNET_SCHEDULER_NO_TASK != rocc->tcc.task) GNUNET_SCHEDULER_cancel (rocc->tcc.task); //GNUNET_TRANSPORT_disconnect (rocc->tcc.th_); GST_cache_get_handle_done (rocc->tcc.cgh_th); 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); } /** * Task to timeout rocc and cleanit up * * @param cls the RemoteOverlayConnectCtx * @param tc the TaskContext from scheduler */ static void timeout_rocc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct RemoteOverlayConnectCtx *rocc = cls; GNUNET_assert (rocc->timeout_rocc_task_id != GNUNET_SCHEDULER_NO_TASK); rocc->timeout_rocc_task_id = GNUNET_SCHEDULER_NO_TASK; LOG_DEBUG ("0x%llx: rocc timed out\n", rocc->op_id); cleanup_rocc (rocc); } /** * Function called to notify transport users that another * peer connected to us. * * @param cls closure * @param new_peer the peer that connected * @param ats performance data * @param ats_count number of entries in ats (excluding 0-termination) */ 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 %4s connected\n", rocc->op_id, GNUNET_i2s (&rocc->a_id)); cleanup_rocc (rocc); } /** * Task to offer the HELLO message to the peer and ask it to connect to the peer * whose identity is in RemoteOverlayConnectCtx * * @param cls the RemoteOverlayConnectCtx * @param tc the TaskContext from scheduler */ static void attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); /** * Task that is run when hello has been sent * * @param cls the overlay connect context * @param tc the scheduler task context; if tc->reason = * GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if * GNUNET_SCHEDULER_REASON_READ_READY is succeeded */ static void rocc_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct RemoteOverlayConnectCtx *rocc = cls; rocc->ohh = NULL; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rocc->attempt_connect_task_id); LOG_DEBUG ("0x%llx: HELLO of peer %4s sent to local peer with id: %u\n", rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id); if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason) { GNUNET_break (0); rocc->attempt_connect_task_id = GNUNET_SCHEDULER_add_now (&attempt_connect_task, rocc); return; } if (GNUNET_SCHEDULER_REASON_READ_READY != tc->reason) return; rocc->tcc.task = GNUNET_SCHEDULER_add_now (&try_connect_task, &rocc->tcc); } /** * Task to offer the HELLO message to the peer and ask it to connect to the peer * whose identity is in RemoteOverlayConnectCtx * * @param cls the RemoteOverlayConnectCtx * @param tc the TaskContext from scheduler */ static void attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct RemoteOverlayConnectCtx *rocc = cls; GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id); rocc->attempt_connect_task_id = GNUNET_SCHEDULER_NO_TASK; LOG_DEBUG ("0x%llx: Offering HELLO of peer %4s to local peer with id: %u\n", rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id); rocc->ohh = GNUNET_TRANSPORT_offer_hello (rocc->tcc.th_, 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); } /** * Callback from cache with needed handles set * * @param cls the closure passed to GST_cache_get_handle_transport() * @param ch the handle to CORE. Can be NULL if it is not requested * @param th the handle to TRANSPORT. Can be NULL if it is not requested * @param ignore_ peer identity which is ignored in this callback */ static void rocc_cache_get_handle_transport_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_Handle *th, const struct GNUNET_PeerIdentity *ignore_) { 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.pid = &rocc->a_id; if (GNUNET_YES == GNUNET_TRANSPORT_check_neighbour_connected (rocc->tcc.th_, rocc->tcc.pid)) { LOG_DEBUG ("0x%llx: Target peer %4s 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); } /** * Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages * * @param cls NULL * @param client identification of the client * @param message the actual message */ void GST_handle_remote_overlay_connect (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg; struct RemoteOverlayConnectCtx *rocc; struct Peer *peer; uint32_t peer_id; uint16_t msize; uint16_t hsize; msize = ntohs (message->size); if (sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) >= msize) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } msg = (const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *) message; if ((NULL == msg->hello) || (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type))) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } hsize = ntohs (msg->hello->size); if ((sizeof (struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) != msize) { GNUNET_break (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } peer_id = ntohl (msg->peer); if ((peer_id >= GST_peer_list_size) || (NULL == (peer = GST_peer_list[peer_id]))) { GNUNET_break_op (0); GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); return; } if (GNUNET_YES == peer->is_remote) { struct GNUNET_MessageHeader *msg2; msg2 = GNUNET_copy_message (message); GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller, msg2); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } rocc = GNUNET_malloc (sizeof (struct RemoteOverlayConnectCtx)); rocc->op_id = GNUNET_ntohll (msg->operation_id); GNUNET_CONTAINER_DLL_insert_tail (roccq_head, roccq_tail, rocc); memcpy (&rocc->a_id, &msg->peer_identity, sizeof (struct GNUNET_PeerIdentity)); LOG_DEBUG ("Received request for overlay connection with op_id: 0x%llx " "from local peer %u to peer %4s with hello size: %u\n", rocc->op_id, peer_id, GNUNET_i2s (&rocc->a_id), hsize); rocc->peer = peer; rocc->peer->reference_cnt++; rocc->hello = GNUNET_malloc (hsize); memcpy (rocc->hello, msg->hello, hsize); rocc->tcc.cgh_th = GST_cache_get_handle_transport (peer_id, rocc->peer->details.local.cfg, &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 (TIMEOUT, &timeout_rocc_task, rocc); GNUNET_SERVER_receive_done (client, GNUNET_OK); } /** * Clears all pending overlay connect contexts in queue */ void GST_free_occq () { struct OverlayConnectContext *occ; while (NULL != (occ = occq_head)) cleanup_occ (occ); } /** * Clears all pending remote overlay connect contexts in queue */ void GST_free_roccq () { struct RemoteOverlayConnectCtx *rocc; while (NULL != (rocc = roccq_head)) cleanup_rocc (rocc); }