*/
#include "gnunet-service-testbed.h"
-#include "testbed_api_operations.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 transport try connect
+ * Context information for requesting TRANSPORT to connect to a peer
*/
struct TryConnectContext
{
struct GNUNET_PeerIdentity *pid;
/**
- * The transport handle
+ * The transport handle obtained from cache. Do NOT close/disconnect.
+ */
+ struct GNUNET_TRANSPORT_Handle *th_;
+
+ /**
+ * The GetCacheHandle for the p1th transport handle
*/
- struct GNUNET_TRANSPORT_Handle *th;
+ struct GSTCacheGetHandle *cgh_th;
/**
* the try connect handle
/**
- * Context information for connecting 2 peers in overlay
+ * Context information for connecting 2 peers in overlay.
*/
struct OverlayConnectContext
{
/**
- * The next pointer for maintaining a DLL
+ * The next pointer for maintaining a DLL of all OverlayConnectContexts
*/
struct OverlayConnectContext *next;
/**
- * The prev pointer for maintaining a DLL
+ * The prev pointer for maintaining a DLL of all OverlayConnectContexts
*/
struct OverlayConnectContext *prev;
/**
- * The client which has requested for overlay connection
+ * 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 peer which has to connect to the other peer
+ * the first peer which is to expect an overlay connection from the second peer.
*/
struct Peer *peer;
/**
- * Transport handle of the first peer to get its HELLO
+ * Transport handle of the first peer obtained from cache to get its HELLO. Do
+ * NOT close/disconnect.
*/
- struct GNUNET_TRANSPORT_Handle *p1th;
+ struct GNUNET_TRANSPORT_Handle *p1th_;
/**
- * Core handles of the first peer; used to notify when second peer connects to it
+ * The CacheGetHandle for the p1th transport handle
*/
- struct GNUNET_CORE_Handle *ch;
+ struct GSTCacheGetHandle *cgh_p1th;
/**
- * HELLO of the other peer
+ * 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 hello handle to acquire HELLO of first peer
+ * Get GetHelloHandle to acquire a HELLO of the first peer
*/
struct GNUNET_TRANSPORT_GetHelloHandle *ghh;
/**
- * The handle for offering HELLO
+ * 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;
char *emsg;
/**
- * Operation context for suboperations
+ * Operation context for the suboperation we start to get the identity of the
+ * second peer if it is a remote peer
*/
struct OperationContext *opc;
/**
- * The local operation we create for this overlay connection
- */
- struct GNUNET_TESTBED_Operation *lop;
-
- /**
- * Controller of peer 2; NULL if the peer is local
+ * Controller of peer 2; NULL if the peer is a local peer
*/
struct GNUNET_TESTBED_Controller *peer2_controller;
/**
- * The transport try connect context
+ * The transport TryConnectContext. This will be NULL if the second peer is a
+ * remote peer
*/
struct TryConnectContext tcc;
/**
- * Context information for RequestOverlayConnect
- * operations. RequestOverlayConnect is used when peers A, B reside on different
- * hosts and the host controller for peer B is asked by the host controller of
- * peer A to make peer B connect to peer A
+ * 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
{
*/
struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;
- /**
- * The local operation we create for this overlay connection
- */
- struct GNUNET_TESTBED_Operation *lop;
-
/**
* The transport try connect context
*/
GNUNET_free (focc->orig_msg);
focc->orig_msg = NULL;
fopc->timeout_task =
- GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_overlay_connect_timeout,
+ 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 (struct OverlayConnectContext *occ)
{
- if (NULL != occ->lop)
- {
- GNUNET_TESTBED_operation_release_ (occ->lop);
- return;
- }
LOG_DEBUG ("0x%llx: Cleaning up occ\n", occ->op_id);
GNUNET_free_non_null (occ->emsg);
GNUNET_free_non_null (occ->hello);
GNUNET_SCHEDULER_cancel (occ->cleanup_task);
if (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task)
GNUNET_SCHEDULER_cancel (occ->timeout_task);
- if (NULL != occ->ch)
+ if (NULL != occ->cgh_ch)
{
- GNUNET_CORE_disconnect (occ->ch);
+ GST_cache_get_handle_done (occ->cgh_ch);
occ->peer->reference_cnt--;
}
if (NULL != occ->ghh)
GNUNET_SCHEDULER_cancel (occ->tcc.task);
if (NULL != occ->tcc.tch)
GNUNET_TRANSPORT_try_connect_cancel (occ->tcc.tch);
- if (NULL != occ->p1th)
+ if (NULL != occ->cgh_p1th)
{
- GNUNET_TRANSPORT_disconnect (occ->p1th);
+ GST_cache_get_handle_done (occ->cgh_p1th);
occ->peer->reference_cnt--;
}
- if (NULL != occ->tcc.th)
+ if (NULL != occ->tcc.cgh_th)
{
- GNUNET_TRANSPORT_disconnect (occ->tcc.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 == 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_assert (NULL == occ->lop);
GNUNET_free (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
- * @param ats performance data
- * @param ats_count number of entries in ats (excluding 0-termination)
*/
static void
-overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer,
- const struct GNUNET_ATS_Information *ats,
- unsigned int ats_count)
+overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
{
struct OverlayConnectContext *occ = cls;
- struct GNUNET_TESTBED_ConnectionEventMessage *msg;
char *new_peer_str;
char *other_peer_str;
}
GNUNET_free_non_null (occ->emsg);
occ->emsg = NULL;
- 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);
+ send_overlay_connect_success_msg (occ);
occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ);
//cleanup_occ (occ);
}
return;
GNUNET_assert (NULL == tcc->tch);
GNUNET_assert (NULL != tcc->pid);
- GNUNET_assert (NULL != tcc->th);
+ 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);
+ GNUNET_TRANSPORT_try_connect (tcc->th_, tcc->pid, &try_connect_cb, tcc);
}
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,
+ GNUNET_TRANSPORT_offer_hello (occ->tcc.th_, occ->hello,
occ_hello_sent_cb, occ);
if (NULL == occ->ohh)
{
}
+/**
+ * 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
GNUNET_assert (NULL == occ->emsg);
GNUNET_assert (NULL != occ->hello);
GNUNET_assert (NULL == occ->ghh);
- GNUNET_assert (NULL == occ->p1th);
+ 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.th =
- GNUNET_TRANSPORT_connect (GST_peer_list[occ->other_peer_id]->
- details.local.cfg, &occ->other_peer_identity,
- NULL, NULL, NULL, NULL);
- if (NULL == occ->tcc.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.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));
LOG_DEBUG ("0x%llx: Received HELLO of %s\n", occ->op_id,
GNUNET_i2s (&occ->peer_identity));
occ->hello = GNUNET_malloc (msize);
- GST_hello_cache_add (&occ->peer_identity, hello);
+ GST_cache_add_hello (occ->peer_id, hello);
memcpy (occ->hello, hello, msize);
GNUNET_TRANSPORT_get_hello_cancel (occ->ghh);
occ->ghh = NULL;
- GNUNET_TRANSPORT_disconnect (occ->p1th);
- occ->p1th = 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);
/**
- * Function called after GNUNET_CORE_connect has succeeded (or failed
- * for good). Note that the private key of the peer is intentionally
- * not exposed here; if you need it, your process should try to read
- * the private key file directly (which should work if you are
- * authorized...).
+ * Callback from cache with needed handles set
*
- * @param cls closure
- * @param server handle to the server, NULL if we failed
- * @param my_identity ID of this peer, NULL if we failed
+ * @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
-core_startup_cb (void *cls, struct GNUNET_CORE_Handle *server,
- const struct GNUNET_PeerIdentity *my_identity)
+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;
- const struct GNUNET_MessageHeader *hello;
GNUNET_free_non_null (occ->emsg);
- (void) GNUNET_asprintf (&occ->emsg,
- "0x%llx: Failed to connect to CORE of peer with"
- "id: %u", occ->op_id, occ->peer_id);
- if ((NULL == server) || (NULL == my_identity))
- goto error_return;
- GNUNET_free (occ->emsg);
- occ->ch = server;
occ->emsg = NULL;
- 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_hello_cache_lookup (&occ->peer_identity)))
- {
- 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;
- }
- occ->peer->reference_cnt++;
- occ->p1th =
- GNUNET_TRANSPORT_connect (occ->peer->details.local.cfg,
- &occ->peer_identity, NULL, NULL, NULL, NULL);
- if (NULL == occ->p1th)
+ if (NULL == th)
{
- GNUNET_asprintf (&occ->emsg,
- "0x%llx: Cannot connect to TRANSPORT of peer %4s",
+ GNUNET_asprintf (&occ->emsg, "0x%llx: Cannot connect to TRANSPORT of %s",
occ->op_id, GNUNET_i2s (&occ->peer_identity));
- goto error_return;
+ 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);
- return;
-
-error_return:
- GNUNET_SCHEDULER_cancel (occ->timeout_task);
- occ->timeout_task = GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
- return;
+ occ->ghh = GNUNET_TRANSPORT_get_hello (occ->p1th_, &hello_update_cb, occ);
}
/**
- * Callback which will be called when overlay connect operation is started
+ * Callback from cache with needed handles set
*
- * @param cls the closure from GNUNET_TESTBED_operation_create_()
+ * @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
-opstart_overlay_connect (void *cls)
+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;
- const struct GNUNET_CORE_MessageHandler no_handlers[] = {
- {NULL, 0, 0}
- };
-
- GNUNET_assert (NULL != occ->lop);
- /* Connect to the core of 1st peer and wait for the 2nd peer to connect */
- occ->emsg = GNUNET_strdup ("Timeout while connecting to CORE");
- 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->ch =
- GNUNET_CORE_connect (occ->peer->details.local.cfg, occ, &core_startup_cb,
- &overlay_connect_notify, NULL, NULL, GNUNET_NO, NULL,
- GNUNET_NO, no_handlers);
- if (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task)
+ 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);
- if (NULL == occ->ch)
occ->timeout_task =
GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
- else
- occ->timeout_task =
- GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_overlay_connect, occ);
-}
-
-
-/**
- * Callback which will be called when overlay connect operation is released
- *
- * @param cls the closure from GNUNET_TESTBED_operation_create_()
- */
-static void
-oprelease_overlay_connect (void *cls)
-{
- struct OverlayConnectContext *occ = cls;
-
- GNUNET_assert (NULL != occ->lop);
- occ->lop = NULL;
- cleanup_occ (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;
}
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);
memcpy (&occ->other_peer_identity, &cmsg->peer_identity,
sizeof (struct GNUNET_PeerIdentity));
GNUNET_free_non_null (occ->emsg);
- occ->emsg = NULL;
- GNUNET_assert (NULL == occ->lop);
- occ->lop =
- GNUNET_TESTBED_operation_create_ (occ, &opstart_overlay_connect,
- &oprelease_overlay_connect);
- /* This operation needs in total 2 connections (one to core and one to
- * transport) */
- GNUNET_TESTBED_operation_queue_insert2_ (GST_opq_openfds, occ->lop, 2);
- GNUNET_TESTBED_operation_begin_wait_ (occ->lop);
+ 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;
}
&GST_forwarded_operation_reply_relay,
fopc);
fopc->timeout_task =
- GNUNET_SCHEDULER_add_delayed (TIMEOUT, &GST_forwarded_operation_timeout,
+ GNUNET_SCHEDULER_add_delayed (GST_timeout, &GST_forwarded_operation_timeout,
fopc);
GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
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 (GST_timeout, &timeout_overlay_connect, occ);
/* Get the identity of the second peer */
if (NULL != occ->peer2_controller)
{
GNUNET_asprintf (&occ->emsg,
"0x%llx: Timeout while getting peer identity of peer "
"with id: %u", occ->op_id, occ->other_peer_id);
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->timeout_task);
- occ->timeout_task =
- GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_overlay_connect, occ);
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);
- occ->lop =
- GNUNET_TESTBED_operation_create_ (occ, &opstart_overlay_connect,
- &oprelease_overlay_connect);
- /* This operation needs in total 2 connections (one to core and one to
- * transport) */
- GNUNET_TESTBED_operation_queue_insert2_ (GST_opq_openfds, occ->lop, 2);
- GNUNET_TESTBED_operation_begin_wait_ (occ->lop);
+ 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);
}
static void
cleanup_rocc (struct RemoteOverlayConnectCtx *rocc)
{
- if (NULL != rocc->lop)
- {
- GNUNET_TESTBED_operation_release_ (rocc->lop);
- return;
- }
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);
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);
+ //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))
* @param ats_count number of entries in ats (excluding 0-termination)
*/
static void
-transport_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer,
- const struct GNUNET_ATS_Information *ats,
- uint32_t ats_count)
+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);
- if (0 != memcmp (new_peer, &rocc->a_id, sizeof (struct GNUNET_PeerIdentity)))
- return;
+ 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);
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,
+ GNUNET_TRANSPORT_offer_hello (rocc->tcc.th_, rocc->hello,
rocc_hello_sent_cb, rocc);
if (NULL == rocc->ohh)
rocc->attempt_connect_task_id =
/**
- * Callback which will be called when remote overlay connect operation is
- * started
+ * Callback from cache with needed handles set
*
- * @param cls the remote overlay connect context
+ * @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
-opstart_remote_overlay_connect (void *cls)
+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;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rocc->timeout_rocc_task_id);
- rocc->tcc.op_id = rocc->op_id;
- rocc->tcc.th =
- GNUNET_TRANSPORT_connect (rocc->peer->details.local.cfg, NULL, rocc, NULL,
- &transport_connect_notify, NULL);
- if (NULL == rocc->tcc.th)
+ 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);
- rocc->timeout_rocc_task_id =
- GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_rocc_task, rocc);
}
-/**
- * Callback which will be called when remote overlay connect operation is
- * released
- *
- * @param cls the remote overlay connect context
- */
-static void
-oprelease_remote_overlay_connect (void *cls)
-{
- struct RemoteOverlayConnectCtx *rocc = cls;
-
- GNUNET_assert (NULL != rocc->lop);
- rocc->lop = NULL;
- cleanup_rocc (rocc);
-}
-
/**
* Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages
*
rocc->peer->reference_cnt++;
rocc->hello = GNUNET_malloc (hsize);
memcpy (rocc->hello, msg->hello, hsize);
- rocc->lop =
- GNUNET_TESTBED_operation_create_ (rocc, &opstart_remote_overlay_connect,
- &oprelease_remote_overlay_connect);
- /* This operation needs only 1 connection to transport */
- GNUNET_TESTBED_operation_queue_insert2_ (GST_opq_openfds, rocc->lop, 1);
- GNUNET_TESTBED_operation_begin_wait_ (rocc->lop);
+ 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 (GST_timeout, &timeout_rocc_task, rocc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
projects / oweals / gnunet.git / blobdiff