/*
This file is part of GNUnet.
- (C) 2008--2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008--2015 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
*/
#include "gnunet-service-testbed.h"
+#include "gnunet-service-testbed_connectionpool.h"
/**
* Redefine LOG with a changed log component string
/**
- * Context information for requesting TRANSPORT to connect to a peer
+ * Context information for requesting ATS to connect to a peer
*/
-struct TryConnectContext
+struct ConnectivitySuggestContext
{
- /**
- * 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
+ * The GetCacheHandle for the peer2's transport handle
+ * (used to offer the HELLO to the peer).
*/
- struct GSTCacheGetHandle *cgh_th;
+ struct GST_ConnectionPool_GetHandle *cgh_p2_th;
/**
- * the try connect handle
+ * The GetCacheHandle for the peer2's ATS handle.
*/
- struct GNUNET_TRANSPORT_TryConnectHandle *tch;
+ struct GST_ConnectionPool_GetHandle *cgh_p2_ats;
/**
- * The task handle
+ * The ATS handle for the connectivity suggestion.
*/
- 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;
+ struct GNUNET_ATS_ConnectivitySuggestHandle *csh;
};
* has to be made between local peers
*/
OCC_TYPE_LOCAL,
-
+
/**
* Type to be used when the first peer is local and the other peer is on a slave
* controller started by us
* contexts
*/
struct LocalPeer2Context
-{
+{
/**
* The handle for offering the HELLO of the first peer to the second
* peer.
struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;
/**
- * The transport TryConnectContext
+ * The transport ConnectivitySuggestContext
*/
- struct TryConnectContext tcc;
+ struct ConnectivitySuggestContext tcc;
};
* contexts
*/
struct RemotePeer2Context
-{
+{
/**
- * Controller of peer 2; If OCC_TYPE_REMOTE_LATERAL is the type of overlay
+ * Controller of peer 2; If #OCC_TYPE_REMOTE_LATERAL is the type of overlay
* connection then this can be NULL until the connection to the controller is
* established
*/
struct GNUNET_TESTBED_Controller *p2c;
-
+
/**
* Operation context for the suboperation we start to get the identity of the
* second peer
*/
struct OperationContext *opc;
-
+
/**
* Notification handle acquire to connect to a remote controller. Only used
- * if the type of overlay connection is OCC_TYPE_REMOTE_LATERAL.
+ * if the type of overlay connection is #OCC_TYPE_REMOTE_LATERAL.
*/
struct NeighbourConnectNotification *ncn;
/**
* The neighbour handle. Only used if the type of overlay connection is
- * OCC_TYPE_REMOTE_LATERAL.
+ * #OCC_TYPE_REMOTE_LATERAL.
*/
- struct Neighbour *p2n;
+ struct Neighbour *p2n;
};
/**
struct GNUNET_TRANSPORT_Handle *p1th_;
/**
- * The CacheGetHandle for the p1th transport handle
+ * The #GST_ConnectionPool_GetHandle for the peer1's transport handle
*/
- struct GSTCacheGetHandle *cgh_p1th;
+ struct GST_ConnectionPool_GetHandle *cgh_p1th;
/**
- * The GetCacheHandle for registering callback to notify CORE level peer
- * connects and to get our identity.
+ * The #GST_ConnectionPool_GetHandle for registering callback to notify CORE
+ * level peer connects and to get our identity.
*/
- struct GSTCacheGetHandle *cgh_ch;
+ struct GST_ConnectionPool_GetHandle *cgh_ch;
/**
* HELLO of the first peer. This should be sent to the second peer.
* 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;
+ struct GNUNET_SCHEDULER_Task *send_hello_task;
/**
* The id of the overlay connect timeout task
*/
- GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ struct GNUNET_SCHEDULER_Task *timeout_task;
/**
* The id of the cleanup task
*/
- GNUNET_SCHEDULER_TaskIdentifier cleanup_task;
+ struct GNUNET_SCHEDULER_Task *cleanup_task;
/**
* The type of this context information
/**
* The transport try connect context
*/
- struct TryConnectContext tcc;
+ struct ConnectivitySuggestContext tcc;
/**
* The peer identity of peer A
/**
* Task for offering HELLO of A to B and doing try_connect
*/
- GNUNET_SCHEDULER_TaskIdentifier attempt_connect_task_id;
+ struct GNUNET_SCHEDULER_Task *attempt_connect_task_id;
/**
* Task to timeout RequestOverlayConnect
*/
- GNUNET_SCHEDULER_TaskIdentifier timeout_rocc_task_id;
+ struct GNUNET_SCHEDULER_Task *timeout_rocc_task_id;
/**
* The id of the operation responsible for creating this context
void
GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc)
{
- GNUNET_SERVER_client_drop (focc->client);
+ GNUNET_SERVER_client_drop (focc->client);
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)
+forwarded_overlay_connect_timeout (void *cls)
{
struct ForwardedOperationContext *fopc = cls;
struct RegisteredHostContext *rhc;
LOG_DEBUG ("Overlay linking between peers %u and %u failed\n", focc->peer1,
focc->peer2);
GST_cleanup_focc (focc);
- GST_forwarded_operation_timeout (fopc, tc);
+ GST_forwarded_operation_timeout (fopc);
if (NULL != rhc->focc_dll_head)
GST_process_next_focc (rhc);
}
peer = GST_peer_list[focc->peer1];
GNUNET_assert (GNUNET_YES == peer->is_remote);
GNUNET_assert (NULL != (slave = peer->details.remote.slave));
- fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ fopc = GNUNET_new (struct ForwardedOperationContext);
GNUNET_SERVER_client_keep (focc->client);
fopc->client = focc->client;
fopc->operation_id = focc->operation_id;
cleanup_occ_lp2c (struct LocalPeer2Context *lp2c)
{
if (NULL != lp2c->ohh)
+ {
GNUNET_TRANSPORT_offer_hello_cancel (lp2c->ohh);
- if (NULL != lp2c->tcc.cgh_th)
- GST_cache_get_handle_done (lp2c->tcc.cgh_th);
- if (NULL != lp2c->tcc.tch)
- GNUNET_TRANSPORT_try_connect_cancel (lp2c->tcc.tch);
- if (GNUNET_SCHEDULER_NO_TASK != lp2c->tcc.task)
- GNUNET_SCHEDULER_cancel (lp2c->tcc.task);
+ 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;
+ }
}
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;
+ }
}
/**
{
struct Peer *peer2;
- LOG_DEBUG ("0x%llx: Cleaning up occ\n", occ->op_id);
+ 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 (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
+ if (NULL != occ->send_hello_task)
GNUNET_SCHEDULER_cancel (occ->send_hello_task);
- if (GNUNET_SCHEDULER_NO_TASK != occ->cleanup_task)
+ if (NULL != occ->cleanup_task)
GNUNET_SCHEDULER_cancel (occ->cleanup_task);
- if (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task)
+ if (NULL != occ->timeout_task)
GNUNET_SCHEDULER_cancel (occ->timeout_task);
if (NULL != occ->cgh_ch)
- GST_cache_get_handle_done (occ->cgh_ch);
+ GST_connection_pool_get_handle_done (occ->cgh_ch);
if (NULL != occ->ghh)
GNUNET_TRANSPORT_get_hello_cancel (occ->ghh);
- if (NULL != occ->cgh_p1th)
- GST_cache_get_handle_done (occ->cgh_p1th);
+ GST_connection_pool_get_handle_done (occ->cgh_p1th);
GNUNET_assert (NULL != GST_peer_list);
- GNUNET_assert (occ->peer->reference_cnt > 0);
+ GNUNET_assert (occ->peer->reference_cnt > 0);
occ->peer->reference_cnt--;
if (PEER_EXPIRED (occ->peer))
GST_destroy_peer (occ->peer);
cleanup_occ_rp2c (&occ->p2ctx.remote);
break;
}
- GNUNET_CONTAINER_DLL_remove (occq_head, occq_tail, occ);
+ 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)
+do_cleanup_occ (void *cls)
{
struct OverlayConnectContext *occ = cls;
- occ->cleanup_task = GNUNET_SCHEDULER_NO_TASK;
+ occ->cleanup_task = NULL;
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)
+timeout_overlay_connect (void *cls)
{
struct OverlayConnectContext *occ = cls;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
- occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ 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);
+ GST_send_operation_fail_msg (occ->client,
+ occ->op_id,
+ occ->emsg);
cleanup_occ (occ);
}
+/**
+ * FIXME.
+ */
static void
send_overlay_connect_success_msg (struct OverlayConnectContext *occ)
{
LOG_DEBUG ("0x%llx: Peers connected - Sending overlay connect success\n",
occ->op_id);
- msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
+ msg = GNUNET_new (struct GNUNET_TESTBED_ConnectionEventMessage);
msg->header.size =
htons (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT);
* @param new_peer the peer that connected
*/
static void
-overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
+overlay_connect_notify (void *cls,
+ const struct GNUNET_PeerIdentity *new_peer)
{
struct OverlayConnectContext *occ = cls;
- struct LocalPeer2Context *lp2c;
char *new_peer_str;
char *other_peer_str;
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,
+ 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);
+ 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 %4s connected to peer %4s\n", occ->op_id,
- other_peer_str, GNUNET_i2s (&occ->peer_identity));
+ 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 (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
+ if (NULL != occ->send_hello_task)
{
GNUNET_SCHEDULER_cancel (occ->send_hello_task);
- occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK;
+ occ->send_hello_task = NULL;
}
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
+ GNUNET_assert (NULL != occ->timeout_task);
GNUNET_SCHEDULER_cancel (occ->timeout_task);
- occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- if (OCC_TYPE_LOCAL == occ->type)
+ occ->timeout_task = NULL;
+ switch (occ->type)
{
- lp2c = &occ->p2ctx.local;
- if (GNUNET_SCHEDULER_NO_TASK != lp2c->tcc.task)
- {
- GNUNET_SCHEDULER_cancel (lp2c->tcc.task);
- lp2c->tcc.task = GNUNET_SCHEDULER_NO_TASK;
- }
+ 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);
+ occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ,
+ occ);
}
/**
- * Task to ask transport of a peer to connect to another peer
+ * Callback from cache with needed ATS handle set
*
- * @param cls the TryConnectContext
- * @param tc the scheduler task context
+ * @param cls a `struct OverlayConnectCtx *`
+ * @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 ac the handle to ATS. Can be NULL if it is not requested
+ * @param my_identity the identity of our peer
*/
static void
-try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+occ_cache_get_handle_ats_occ_cb (void *cls,
+ struct GNUNET_CORE_Handle *ch,
+ struct GNUNET_TRANSPORT_Handle *th,
+ struct GNUNET_ATS_ConnectivityHandle *ac,
+ const struct GNUNET_PeerIdentity *my_identity)
+{
+ 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;
-/**
- * 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);
+ 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);
}
/**
- * Task to ask transport of a peer to connect to another peer
+ * Callback from cache with needed ATS handle set
*
- * @param cls the TryConnectContext
- * @param tc the scheduler task context
+ * @param cls a `struct RemoteOverlayConnectCtx *`
+ * @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 ac the handle to ATS. Can be NULL if it is not requested
+ * @param my_identity the identity of our peer
*/
static void
-try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+occ_cache_get_handle_ats_rocc_cb (void *cls,
+ struct GNUNET_CORE_Handle *ch,
+ struct GNUNET_TRANSPORT_Handle *th,
+ struct GNUNET_ATS_ConnectivityHandle *ac,
+ const struct GNUNET_PeerIdentity *my_identity)
{
- struct TryConnectContext *tcc = cls;
+ struct RemoteOverlayConnectCtx *rocc = 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 %4s\n", tcc->op_id,
- tcc->retries, GNUNET_i2s (tcc->pid));
- tcc->tch =
- GNUNET_TRANSPORT_try_connect (tcc->th_, tcc->pid, &try_connect_cb, tcc);
+ rocc->tcc.csh =
+ GNUNET_ATS_connectivity_suggest (ac,
+ &rocc->a_id,
+ 1);
}
* peer 1.
*
* @param cls the OverlayConnectContext
- * @param tc the TaskContext from scheduler
*/
static void
-send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+send_hello (void *cls);
/**
- * Task that is run when hello has been sent
+ * Task that is run when hello has been sent If tc->reason =
+ * #GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if
+ * #GNUNET_SCHEDULER_REASON_READ_READY is succeeded
*
* @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)
+occ_hello_sent_cb (void *cls)
{
struct OverlayConnectContext *occ = cls;
struct LocalPeer2Context *lp2c;
+ struct Peer *peer2;
+ const struct GNUNET_SCHEDULER_TaskContext *tc;
+ tc = GNUNET_SCHEDULER_get_task_context ();
GNUNET_assert (OCC_TYPE_LOCAL == occ->type);
+ GNUNET_assert (NULL != occ->timeout_task);
lp2c = &occ->p2ctx.local;
lp2c->ohh = NULL;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->send_hello_task);
+
+ GNUNET_assert (NULL == 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);
+ 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 during TRANSPORT_try_connect() "
- "at peer %4s", occ->op_id,
- GNUNET_i2s(&occ->other_peer_identity));
- lp2c->tcc.pid = &occ->peer_identity;
- lp2c->tcc.op_id = occ->op_id;
- lp2c->tcc.task = GNUNET_SCHEDULER_add_now (&try_connect_task, &lp2c->tcc);
+ "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);
}
* request.
*
* @param occ the overlay connect context. Its type must be either
- * OCC_TYPE_REMOTE_SLAVE or OCC_TYPE_REMOTE_LATERAL
+ * #OCC_TYPE_REMOTE_SLAVE or #OCC_TYPE_REMOTE_LATERAL
*/
-void
+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_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;
+ 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->p2ctx.remote.p2c, &msg->header);
+ msg->peer_identity = occ->peer_identity;
+ memcpy (msg->hello,
+ occ->hello,
+ hello_size);
+ GNUNET_TESTBED_queue_message_ (occ->p2ctx.remote.p2c,
+ &msg->header);
}
* send_hello_thru_rocc()
*
* @param cls the OverlayConnectContext
- * @param tc the TaskContext from scheduler
*/
static void
-send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+send_hello (void *cls)
{
struct OverlayConnectContext *occ = cls;
struct LocalPeer2Context *lp2c;
char *other_peer_str;
- occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK;
- if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
- return;
+ occ->send_hello_task = NULL;
+ GNUNET_assert (NULL != occ->timeout_task);
GNUNET_assert (NULL != occ->hello);
if (OCC_TYPE_LOCAL != occ->type)
{
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);
+ 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.th_, occ->hello,
- occ_hello_sent_cb, occ);
+ GNUNET_TRANSPORT_offer_hello (lp2c->tcc.th_,
+ occ->hello,
+ occ_hello_sent_cb,
+ occ);
if (NULL == lp2c->ohh)
{
GNUNET_break (0);
* @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 ac the handle to ATS. 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,
+p2_transport_connect_cache_callback (void *cls,
+ struct GNUNET_CORE_Handle *ch,
struct GNUNET_TRANSPORT_Handle *th,
+ struct GNUNET_ATS_ConnectivityHandle *ac,
const struct GNUNET_PeerIdentity *ignore_)
{
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_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;
- GNUNET_asprintf (&occ->emsg, "0x%llx: Timeout while offering HELLO to %s",
- occ->op_id, GNUNET_i2s (&occ->other_peer_identity));
+ 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);
}
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_th =
- GST_cache_get_handle_transport (occ->other_peer_id,
+ 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));
+ 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);
}
* @param cls empty flag to set
* @param address the HELLO
* @param expiration expiration of the HELLO
- * @return
+ * @return #GNUNET_OK
*/
static int
-test_address (void *cls, const struct GNUNET_HELLO_Address *address,
+test_address (void *cls,
+ const struct GNUNET_HELLO_Address *address,
struct GNUNET_TIME_Absolute expiration)
{
int *empty = cls;
* @param hello our updated HELLO
*/
static void
-hello_update_cb (void *cls, const struct GNUNET_MessageHeader *hello)
+hello_update_cb (void *cls,
+ const struct GNUNET_MessageHeader *hello)
{
struct OverlayConnectContext *occ = cls;
int empty;
msize = ntohs (hello->size);
empty = GNUNET_YES;
(void) GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *)
- hello, GNUNET_NO, &test_address,
+ hello, GNUNET_NO,
+ &test_address,
&empty);
if (GNUNET_YES == empty)
{
- LOG_DEBUG ("0x%llx: HELLO of %s is empty\n", occ->op_id,
+ 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,
+ 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);
+ GST_connection_pool_get_handle_done (occ->cgh_p1th);
occ->cgh_p1th = NULL;
occ->p1th_ = NULL;
GNUNET_free_non_null (occ->emsg);
* @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 ac the handle to ATS. 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,
+p1_transport_connect_cache_callback (void *cls,
+ struct GNUNET_CORE_Handle *ch,
struct GNUNET_TRANSPORT_Handle *th,
+ struct GNUNET_ATS_ConnectivityHandle *ac,
const struct GNUNET_PeerIdentity *ignore_)
{
struct OverlayConnectContext *occ = cls;
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_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);
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);
+ "0x%llx: Timeout while acquiring HELLO of peer %s",
+ 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
+ * Callback from cache with needed CORE handle 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 ac the handle to ATS. 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,
+occ_cache_get_handle_core_cb (void *cls,
+ struct GNUNET_CORE_Handle *ch,
struct GNUNET_TRANSPORT_Handle *th,
+ struct GNUNET_ATS_ConnectivityHandle *ac,
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_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);
+ "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);
}
occ->emsg = NULL;
if (GNUNET_YES ==
- GNUNET_CORE_is_peer_connected_sync (ch, &occ->other_peer_identity))
+ GNUNET_CORE_is_peer_connected_sync (ch,
+ &occ->other_peer_identity))
{
- LOG_DEBUG ("0x%llx: Target peer already connected\n", occ->op_id);
+ 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;
+ occ->timeout_task = NULL;
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,
+ 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,
+ 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);
}
GNUNET_asprintf (&occ->emsg,
"0x%llx: Timeout while acquiring TRANSPORT of %s from cache",
- occ->op_id, GNUNET_i2s (&occ->peer_identity));
+ occ->op_id,
+ GNUNET_i2s (&occ->peer_identity));
occ->cgh_p1th =
- GST_cache_get_handle_transport (occ->peer->id,
+ GST_connection_pool_get_handle (occ->peer->id,
occ->peer->details.local.cfg,
- p1_transport_connect_cache_callback, occ,
+ GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
+ p1_transport_connect_cache_callback,
+ occ,
NULL, NULL, NULL);
}
* @param msg the peer create success message
*/
static void
-overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg)
+overlay_connect_get_config (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct OverlayConnectContext *occ = cls;
struct RemotePeer2Context *rp2c;
GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
rp2c = &occ->p2ctx.remote;
rp2c->opc = NULL;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
+ GNUNET_assert (NULL != occ->timeout_task);
if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION != ntohs (msg->type))
{
GNUNET_SCHEDULER_cancel (occ->timeout_task);
}
cmsg =
(const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *) msg;
- memcpy (&occ->other_peer_identity, &cmsg->peer_identity,
- sizeof (struct GNUNET_PeerIdentity));
+ 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);
+ "id: %u",
+ occ->op_id,
+ occ->peer->id);
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);
+ 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;
}
host_registration_comp (void *cls, const char *emsg)
{
struct RegisteredHostContext *rhc = cls;
-
+
rhc->state = RHC_DONE;
GST_process_next_focc (rhc);
}
* @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
+ * @return #GNUNET_YES if we should continue to
* iterate,
- * GNUNET_NO if not.
+ * #GNUNET_NO if not.
*/
static int
-reghost_match_iterator (void *cls, const struct GNUNET_HashCode *key,
+reghost_match_iterator (void *cls,
+ const struct GNUNET_HashCode *key,
void *value)
{
struct RegisteredHostContext **rh = cls;
* already registered, NULL is returned.
*/
static struct RegisteredHostContext *
-register_host (struct Slave *slave, struct GNUNET_TESTBED_Host *host)
+register_host (struct Slave *slave,
+ struct GNUNET_TESTBED_Host *host)
{
struct GNUNET_HashCode hash;
struct RegisteredHostContext *rhc;
-
- rhc = GNUNET_malloc (sizeof (struct RegisteredHostContext));
+
+ rhc = GNUNET_new (struct RegisteredHostContext);
rhc->reg_host = host;
rhc->host = GST_host_list[slave->host_id];
GNUNET_assert (NULL != rhc->reg_host);
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) &&
+ 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
GST_host_list[peer2_host_id])))
{
LOG_DEBUG ("Queueing forwarding FOCC for connecting peers %u and %u\n", p1, p2);
- focc = GNUNET_malloc (sizeof (struct ForwardedOverlayConnectContext));
+ focc = GNUNET_new (struct ForwardedOverlayConnectContext);
focc->peer1 = p1;
focc->peer2 = p2;
focc->peer2_host_id = peer2_host_id;
forward:
LOG_DEBUG ("Forwarding without FOCC for connecting peers %u and %u\n", p1, p2);
- fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ fopc = GNUNET_new (struct ForwardedOperationContext);
GNUNET_SERVER_client_keep (client);
fopc->client = client;
fopc->operation_id = op_id;
&GST_forwarded_operation_reply_relay,
fopc);
fopc->timeout_task =
- GNUNET_SCHEDULER_add_delayed (GST_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_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
}
* @param c handle to the controller connection
*/
static void
-p2_controller_connect_cb (void *cls, struct GNUNET_TESTBED_Controller *c)
+p2_controller_connect_cb (void *cls,
+ struct GNUNET_TESTBED_Controller *c)
{
struct OverlayConnectContext *occ = cls;
struct RemotePeer2Context *rp2c;
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);
+ "with id: %u",
+ occ->op_id,
+ occ->other_peer_id);
}
/**
- * Handler for GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT messages
+ * 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,
+GST_handle_overlay_connect (void *cls,
+ struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_TESTBED_OverlayConnectMessage *msg;
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);
+ ("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))
+ if (! VALID_HOST_ID (peer2_host_id))
{
GNUNET_break (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
+ GNUNET_SERVER_receive_done (client,
+ GNUNET_SYSERR);
+ return;
}
forward_overlay_connect (msg, client);
- GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ GNUNET_SERVER_receive_done (client,
+ GNUNET_OK);
return;
}
p2n = NULL;
- occ = GNUNET_malloc (sizeof (struct OverlayConnectContext));
+ 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))
LOG (GNUNET_ERROR_TYPE_WARNING,
"0x%llx: Peer %u's host not in our neighbours list\n",
operation_id, p2);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ GNUNET_SERVER_receive_done (client,
+ GNUNET_SYSERR);
GNUNET_free (occ);
return;
}
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);
+ GNUNET_CONTAINER_DLL_insert_tail (occq_head,
+ occq_tail,
+ occ);
GNUNET_SERVER_client_keep (client);
occ->client = client;
occ->other_peer_id = p2;
GST_peer_list[p1]->reference_cnt++;
- occ->peer = GST_peer_list[p1];
+ occ->peer = GST_peer_list[p1];
occ->op_id = operation_id;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->timeout_task);
+ GNUNET_assert (NULL == occ->timeout_task);
occ->timeout_task =
- GNUNET_SCHEDULER_add_delayed (GST_timeout, &timeout_overlay_connect, occ);
+ 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 =
+ "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:
&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);
+ "id: %u",
+ occ->op_id,
+ occ->peer->id);
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);
+ 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_SERVER_receive_done (client, GNUNET_OK);
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)
+ 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 (GNUNET_SCHEDULER_NO_TASK != rocc->timeout_rocc_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.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);
+ 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_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)
+timeout_rocc_task (void *cls)
{
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);
+ 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);
}
{
struct RemoteOverlayConnectCtx *rocc = cls;
- LOG_DEBUG ("0x%llx: Request Overlay connect notify\n", rocc->op_id);
+ 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,
+ LOG_DEBUG ("0x%llx: Peer %s connected\n",
+ rocc->op_id,
GNUNET_i2s (&rocc->a_id));
cleanup_rocc (rocc);
}
* 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);
+attempt_connect_task (void *cls);
/**
- * Task that is run when hello has been sent
+ * Task that is run when hello has been sent If tc->reason =
+ * #GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if
+ * #GNUNET_SCHEDULER_REASON_READ_READY is succeeded
*
* @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)
+rocc_hello_sent_cb (void *cls)
{
struct RemoteOverlayConnectCtx *rocc = cls;
+ const struct GNUNET_SCHEDULER_TaskContext *tc;
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);
+ 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);
+ tc = GNUNET_SCHEDULER_get_task_context ();
if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason)
{
GNUNET_break (0);
rocc->attempt_connect_task_id =
- GNUNET_SCHEDULER_add_now (&attempt_connect_task, rocc);
+ GNUNET_SCHEDULER_add_now (&attempt_connect_task,
+ rocc);
return;
}
if (GNUNET_SCHEDULER_REASON_READ_READY != tc->reason)
GNUNET_break (0);
return;
}
- rocc->tcc.task = GNUNET_SCHEDULER_add_now (&try_connect_task, &rocc->tcc);
+
+ 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);
+
}
* 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)
+attempt_connect_task (void *cls)
{
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);
+ 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.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 =
* @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 ac the handle to ATS. 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,
+rocc_cache_get_handle_transport_cb (void *cls,
+ struct GNUNET_CORE_Handle *ch,
struct GNUNET_TRANSPORT_Handle *th,
+ struct GNUNET_ATS_ConnectivityHandle *ac,
const struct GNUNET_PeerIdentity *ignore_)
{
struct RemoteOverlayConnectCtx *rocc = cls;
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))
+ GNUNET_TRANSPORT_check_peer_connected (rocc->tcc.th_,
+ &rocc->a_id))
{
- 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);
+ 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;
}
/**
- * Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages
+ * Handler for #GNUNET_MESSAGE_TYPE_TESTBED_REQUEST_CONNECT messages
*
* @param cls NULL
* @param client identification of the client
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
- rocc = GNUNET_malloc (sizeof (struct RemoteOverlayConnectCtx));
+ rocc = GNUNET_new (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));
- GNUNET_TESTING_peer_get_identity (peer->details.local.peer, &pid);
- (void) strncpy (pid_str, GNUNET_i2s (&pid), 15);
- LOG_DEBUG ("0x%llx: Remote overlay connect %4s to peer %4s with hello size: %u\n",
- rocc->op_id, pid_str, GNUNET_i2s (&rocc->a_id), hsize);
+ 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) strncpy (pid_str,
+ GNUNET_i2s (&pid),
+ 15);
+ 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);
memcpy (rocc->hello, msg->hello, hsize);
- rocc->tcc.op_id = rocc->op_id;
- rocc->tcc.cgh_th =
- GST_cache_get_handle_transport (peer_id, rocc->peer->details.local.cfg,
- &rocc_cache_get_handle_transport_cb, rocc,
+ 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_SERVER_receive_done (client, GNUNET_OK);
+ GNUNET_SCHEDULER_add_delayed (GST_timeout,
+ &timeout_rocc_task,
+ rocc);
+ GNUNET_SERVER_receive_done (client,
+ GNUNET_OK);
}