gnunet-service-testbed_oc.c File Reference

code for handling overlay connect operations More...

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

Include dependency graph for gnunet-service-testbed_oc.c:

Go to the source code of this file.

Data Structures
struct	ConnectivitySuggestContext
	Context information for requesting ATS to connect to a peer. More...
struct	LocalPeer2Context
	Context data for operations on second peer in local overlay connection contexts. More...
struct	RemotePeer2Context
	Context data for operations on second peer in remote overlay connection contexts. More...
struct	OverlayConnectContext
	Context information for connecting 2 peers in overlay. More...
struct	RemoteOverlayConnectCtx
	Context information for remote overlay connect operations. More...

Macros
#define	LOG(kind, ...)    GNUNET_log_from (kind, "testbed-OC", __VA_ARGS__)
	Redefine LOG with a changed log component string. More...
#define	PEER_EXPIRED(peer)    ((GNUNET_YES == peer->destroy_flag) && (0 == peer->reference_cnt))
	Condition for checking if given peer is ready to be destroyed. More...

Enumerations
enum	OverlayConnectContextType { OCC_TYPE_LOCAL , OCC_TYPE_REMOTE_SLAVE , OCC_TYPE_REMOTE_LATERAL }
	Types for context information we create for overlay connect requests. More...

Functions
void	GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc)
	Cleans up ForwardedOverlayConnectContext. More...
static void	forwarded_overlay_connect_timeout (void *cls)
	Timeout task for cancelling a forwarded overlay connect connect. More...
static void	forwarded_overlay_connect_listener (void *cls, const struct GNUNET_MessageHeader *msg)
	Callback to be called when forwarded overlay connection operation has a reply from the sub-controller successful. More...
void	GST_process_next_focc (struct RegisteredHostContext *rhc)
	Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext. More...
static void	cleanup_occ_lp2c (struct LocalPeer2Context *lp2c)
	Cleans up any used handles in local peer2 context. More...
static void	cleanup_occ_rp2c (struct RemotePeer2Context *rp2c)
	Cleans up any used handles in remote peer2 context. More...
static void	cleanup_occ (struct OverlayConnectContext *occ)
	Cleanup overlay connect context structure. More...
static void	do_cleanup_occ (void *cls)
	Task for cleaning up overlay connect context structure. More...
static void	timeout_overlay_connect (void *cls)
	Task which will be run when overlay connect request has been timed out. More...
void	GST_notify_client_disconnect_oc (struct GNUNET_SERVICE_Client *client)
	Notify OC subsystem that client disconnected. More...
static void	send_overlay_connect_success_msg (struct OverlayConnectContext *occ)
	FIXME. More...
static void	overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
	Function called to notify transport users that another peer connected to us. More...
static void	occ_cache_get_handle_ats_occ_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Callback from cache with needed ATS handle set. More...
static void	occ_cache_get_handle_ats_rocc_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Callback from cache with needed ATS handle set. More...
static void	send_hello (void *cls)
	Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to peer 1. More...
static void	occ_hello_sent_cb (void *cls)
	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. More...
static void	send_hello_thru_rocc (struct OverlayConnectContext *occ)
	Sends the HELLO of peer1 to peer2's controller through remote overlay connect request. More...
static void	p2_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Callback from cache with needed handles set. More...
static void	p2_transport_connect (struct OverlayConnectContext *occ)
	Connects to the transport of the other peer if it is a local peer and schedules the send hello task. More...
static int	test_address (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
	Test for checking whether HELLO message is empty. More...
static void	hello_update_cb (void *cls, const struct GNUNET_MessageHeader *hello)
	Function called whenever there is an update to the HELLO of peers in the OverlayConnectClosure. More...
static void	p1_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Callback from cache with needed handles set. More...
static void	occ_cache_get_handle_core_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Callback from cache with needed CORE handle set. More...
static void	overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg)
	Callback to be called when forwarded get peer config operation as part of overlay connect is successful. More...
static void	host_registration_comp (void *cls, const char *emsg)
	Callback which will be called after a host registration succeeded or failed. More...
static int	reghost_match_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator to match a registered host context. More...
static struct GNUNET_HashCode	hash_hosts (struct GNUNET_TESTBED_Host *reg_host, struct GNUNET_TESTBED_Host *host)
	Function to generate the hashcode corresponding to a RegisteredHostContext. More...
static struct RegisteredHostContext *	register_host (struct Slave *slave, struct GNUNET_TESTBED_Host *host)
	Checks if the given host is registered at the given slave. More...
static void	forward_overlay_connect (const struct GNUNET_TESTBED_OverlayConnectMessage *msg, struct GNUNET_SERVICE_Client *client)
	Forwards the overlay connect request to a slave controller. More...
static void	p2_controller_connect_cb (void *cls, struct GNUNET_TESTBED_Controller *c)
	Callback called when a connection to the controller of peer2 has been established. More...
void	handle_overlay_connect (void *cls, const struct GNUNET_TESTBED_OverlayConnectMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages. More...
static void	cleanup_rocc (struct RemoteOverlayConnectCtx *rocc)
	Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it. More...
static void	timeout_rocc_task (void *cls)
	Task to timeout rocc and cleanit up. More...
static void	cache_transport_peer_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
	Function called to notify transport users that another peer connected to us. More...
static void	attempt_connect_task (void *cls)
	Task to offer the HELLO message to the peer and ask it to connect to the peer whose identity is in RemoteOverlayConnectCtx. More...
static void	rocc_hello_sent_cb (void *cls)
	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. More...
static void	rocc_cache_get_handle_transport_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Callback from cache with needed handles set. More...
int	check_remote_overlay_connect (void *cls, const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages. More...
void	handle_remote_overlay_connect (void *cls, const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages. More...
void	GST_free_occq ()
	Clears all pending overlay connect contexts in queue. More...
void	GST_free_roccq ()
	Clears all pending remote overlay connect contexts in queue. More...

Variables
static struct OverlayConnectContext *	occq_head
	DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown. More...
static struct OverlayConnectContext *	occq_tail
	DLL tail for OverlayConnectContext DLL. More...
static struct RemoteOverlayConnectCtx *	roccq_head
	DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown. More...
static struct RemoteOverlayConnectCtx *	roccq_tail
	DLL tail for RequectOverlayConnectContext DLL. More...

Detailed Description

code for handling overlay connect operations

Author

Sree Harsha Totakura

Definition in file gnunet-service-testbed_oc.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "testbed-OC", __VA_ARGS__)

Redefine LOG with a changed log component string.

Definition at line 38 of file gnunet-service-testbed_oc.c.

PEER_EXPIRED

#define PEER_EXPIRED

(

peer

)

((GNUNET_YES == peer->destroy_flag) && (0 == peer->reference_cnt))

Condition for checking if given peer is ready to be destroyed.

Parameters

peer	the peer to check

Definition at line 525 of file gnunet-service-testbed_oc.c.

Enumeration Type Documentation

OverlayConnectContextType

enum OverlayConnectContextType

Types for context information we create for overlay connect requests.

Enumerator
OCC_TYPE_LOCAL	This type is used if the overlay connection is local i.e. the connection has to be made between local peers
OCC_TYPE_REMOTE_SLAVE	Type to be used when the first peer is local and the other peer is on a slave controller started by us.
OCC_TYPE_REMOTE_LATERAL	Type to be used when the first peer is local and the other peer is on a controller which is not started by us.

Definition at line 78 of file gnunet-service-testbed_oc.c.

{
  OCC_TYPE_LOCAL,
 
  OCC_TYPE_REMOTE_SLAVE,
 
  OCC_TYPE_REMOTE_LATERAL
};

Function Documentation

GST_cleanup_focc()

void GST_cleanup_focc

(

struct ForwardedOverlayConnectContext *

focc

)

Cleans up ForwardedOverlayConnectContext.

Parameters

focc	the ForwardedOverlayConnectContext to cleanup

Definition at line 357 of file gnunet-service-testbed_oc.c.

{
  struct RegisteredHostContext *rhc = focc->rhc;
 
  GNUNET_CONTAINER_DLL_remove (rhc->focc_dll_head,
                               rhc->focc_dll_tail,
                               focc);
  GNUNET_free (focc->orig_msg);
  GNUNET_free (focc);
}

References RegisteredHostContext::focc_dll_head, RegisteredHostContext::focc_dll_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, ForwardedOverlayConnectContext::orig_msg, and ForwardedOverlayConnectContext::rhc.

Referenced by drop_client_entries(), forwarded_overlay_connect_listener(), forwarded_overlay_connect_timeout(), and reghost_free_iterator().

Here is the caller graph for this function:

forwarded_overlay_connect_timeout()

static void forwarded_overlay_connect_timeout ( void *  cls )

static

Timeout task for cancelling a forwarded overlay connect connect.

Parameters

cls	the struct ForwardedOperationContext

Definition at line 375 of file gnunet-service-testbed_oc.c.

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

References ForwardedOperationContext::cls, RegisteredHostContext::focc_dll_head, GST_cleanup_focc(), GST_forwarded_operation_timeout(), GST_process_next_focc(), LOG_DEBUG, ForwardedOverlayConnectContext::peer1, ForwardedOverlayConnectContext::peer2, ForwardedOverlayConnectContext::rhc, and ForwardedOperationContext::timeout_task.

Referenced by GST_process_next_focc().

Here is the call graph for this function:

Here is the caller graph for this function:

forwarded_overlay_connect_listener()

static void forwarded_overlay_connect_listener ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Callback to be called when forwarded overlay connection operation has a reply from the sub-controller successful.

We have to relay the reply msg back to the client

Parameters

cls	ForwardedOperationContext
msg	the peer create success message

Definition at line 403 of file gnunet-service-testbed_oc.c.

{
  struct ForwardedOperationContext *fopc = cls;
  struct RegisteredHostContext *rhc;
  struct ForwardedOverlayConnectContext *focc;
 
  rhc = fopc->cls;
  GST_forwarded_operation_reply_relay (cls, msg);
  focc = rhc->focc_dll_head;
  GST_cleanup_focc (focc);
  if (NULL != rhc->focc_dll_head)
    GST_process_next_focc (rhc);
}

References ForwardedOperationContext::cls, RegisteredHostContext::focc_dll_head, GST_cleanup_focc(), GST_forwarded_operation_reply_relay(), GST_process_next_focc(), msg, and ForwardedOverlayConnectContext::rhc.

Referenced by GST_process_next_focc().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_process_next_focc()

void GST_process_next_focc

(

struct RegisteredHostContext *

rhc

)

Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext.

Parameters

rhc	the RegisteredHostContext

Definition at line 425 of file gnunet-service-testbed_oc.c.

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

References ForwardedOperationContext::client, ForwardedOverlayConnectContext::client, ForwardedOperationContext::cls, Slave::controller, RegisteredHostContext::focc_dll_head, fopcq_head, fopcq_tail, forwarded_overlay_connect_listener(), forwarded_overlay_connect_timeout(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_free, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_YES, GST_peer_list, GST_timeout, OP_OVERLAY_CONNECT, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, ForwardedOverlayConnectContext::operation_id, ForwardedOverlayConnectContext::orig_msg, peer, ForwardedOverlayConnectContext::peer1, RegisteredHostContext::state, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Referenced by forwarded_overlay_connect_listener(), forwarded_overlay_connect_timeout(), and host_registration_comp().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_occ_lp2c()

static void cleanup_occ_lp2c ( struct LocalPeer2Context *  lp2c )

static

Cleans up any used handles in local peer2 context.

Parameters

lp2c	the local peer2 context information

Definition at line 468 of file gnunet-service-testbed_oc.c.

{
  if (NULL != lp2c->ohh)
  {
    GNUNET_TRANSPORT_offer_hello_cancel (lp2c->ohh);
    lp2c->ohh = NULL;
  }
  if (NULL != lp2c->tcc.cgh_p2_th)
  {
    GST_connection_pool_get_handle_done (lp2c->tcc.cgh_p2_th);
    lp2c->tcc.cgh_p2_th = NULL;
  }
  if (NULL != lp2c->tcc.cgh_p2_ats)
  {
    GST_connection_pool_get_handle_done (lp2c->tcc.cgh_p2_ats);
    lp2c->tcc.cgh_p2_ats = NULL;
  }
  if (NULL != lp2c->tcc.csh)
  {
    GNUNET_ATS_connectivity_suggest_cancel (lp2c->tcc.csh);
    lp2c->tcc.csh = NULL;
  }
}

References ConnectivitySuggestContext::cgh_p2_ats, ConnectivitySuggestContext::cgh_p2_th, ConnectivitySuggestContext::csh, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_TRANSPORT_offer_hello_cancel(), GST_connection_pool_get_handle_done(), LocalPeer2Context::ohh, and LocalPeer2Context::tcc.

Referenced by cleanup_occ(), and overlay_connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_occ_rp2c()

static void cleanup_occ_rp2c ( struct RemotePeer2Context *  rp2c )

static

Cleans up any used handles in remote peer2 context.

Relinquishes the remote controller connection if it has been established on-demand.

Parameters

rp2c	the remote peer2 context information

Definition at line 500 of file gnunet-service-testbed_oc.c.

{
  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;
  }
}

References GNUNET_TESTBED_forward_operation_msg_cancel_(), GST_neighbour_get_connection_cancel(), GST_neighbour_release_connection(), RemotePeer2Context::ncn, RemotePeer2Context::opc, RemotePeer2Context::p2c, and RemotePeer2Context::p2n.

Referenced by cleanup_occ(), and overlay_connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_occ()

static void cleanup_occ ( struct OverlayConnectContext *  occ )

static

Cleanup overlay connect context structure.

Parameters

occ	the overlay connect context

Definition at line 534 of file gnunet-service-testbed_oc.c.

{
  struct Peer *peer2;
 
  LOG_DEBUG ("0x%llx: Cleaning up occ\n",
             (unsigned long long) occ->op_id);
  GNUNET_free (occ->emsg);
  GNUNET_free (occ->hello);
  if (NULL != occ->send_hello_task)
    GNUNET_SCHEDULER_cancel (occ->send_hello_task);
  if (NULL != occ->cleanup_task)
    GNUNET_SCHEDULER_cancel (occ->cleanup_task);
  if (NULL != occ->timeout_task)
    GNUNET_SCHEDULER_cancel (occ->timeout_task);
  if (NULL != occ->cgh_ch)
    GST_connection_pool_get_handle_done (occ->cgh_ch);
  if (NULL != occ->ghh)
    GNUNET_TRANSPORT_hello_get_cancel (occ->ghh);
  GST_connection_pool_get_handle_done (occ->cgh_p1th);
  GNUNET_assert (NULL != GST_peer_list);
  GNUNET_assert (occ->peer->reference_cnt > 0);
  occ->peer->reference_cnt--;
  if (PEER_EXPIRED (occ->peer))
    GST_destroy_peer (occ->peer);
  switch (occ->type)
  {
  case OCC_TYPE_LOCAL:
    peer2 = GST_peer_list[occ->other_peer_id];
    GNUNET_assert (peer2->reference_cnt > 0);
    peer2->reference_cnt--;
    if (PEER_EXPIRED (peer2))
      GST_destroy_peer (peer2);
    cleanup_occ_lp2c (&occ->p2ctx.local);
    break;
 
  case OCC_TYPE_REMOTE_SLAVE:
  case OCC_TYPE_REMOTE_LATERAL:
    cleanup_occ_rp2c (&occ->p2ctx.remote);
    break;
  }
  GNUNET_CONTAINER_DLL_remove (occq_head,
                               occq_tail,
                               occ);
  GNUNET_free (occ);
}

References OverlayConnectContext::cgh_ch, OverlayConnectContext::cgh_p1th, cleanup_occ_lp2c(), cleanup_occ_rp2c(), OverlayConnectContext::cleanup_task, OverlayConnectContext::emsg, OverlayConnectContext::ghh, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_hello_get_cancel(), GST_connection_pool_get_handle_done(), GST_destroy_peer(), GST_peer_list, OverlayConnectContext::hello, OverlayConnectContext::local, LOG_DEBUG, OCC_TYPE_LOCAL, OCC_TYPE_REMOTE_LATERAL, OCC_TYPE_REMOTE_SLAVE, occq_head, occq_tail, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::p2ctx, OverlayConnectContext::peer, PEER_EXPIRED, Peer::reference_cnt, OverlayConnectContext::remote, OverlayConnectContext::send_hello_task, OverlayConnectContext::timeout_task, and OverlayConnectContext::type.

Referenced by do_cleanup_occ(), GST_free_occq(), GST_notify_client_disconnect_oc(), and timeout_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_cleanup_occ()

static void do_cleanup_occ ( void *  cls )

static

Task for cleaning up overlay connect context structure.

Parameters

cls	the overlay connect context

Definition at line 587 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ = cls;
 
  occ->cleanup_task = NULL;
  cleanup_occ (occ);
}

References cleanup_occ(), and OverlayConnectContext::cleanup_task.

Referenced by occ_cache_get_handle_core_cb(), and overlay_connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_overlay_connect()

static void timeout_overlay_connect ( void *  cls )

static

Task which will be run when overlay connect request has been timed out.

Parameters

cls	the OverlayConnectContext

Definition at line 602 of file gnunet-service-testbed_oc.c.

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

References cleanup_occ(), OverlayConnectContext::client, OverlayConnectContext::emsg, GNUNET_assert, GST_send_operation_fail_msg(), OverlayConnectContext::op_id, and OverlayConnectContext::timeout_task.

Referenced by handle_overlay_connect(), occ_cache_get_handle_ats_occ_cb(), occ_cache_get_handle_core_cb(), overlay_connect_get_config(), p1_transport_connect_cache_callback(), and p2_transport_connect_cache_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_notify_client_disconnect_oc()

void GST_notify_client_disconnect_oc

(

struct GNUNET_SERVICE_Client *

client

)

Notify OC subsystem that client disconnected.

Parameters

client

the client that disconnected

Definition at line 624 of file gnunet-service-testbed_oc.c.

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

References cleanup_occ(), ForwardedOperationContext::client, OverlayConnectContext::client, fopcq_head, GNUNET_SCHEDULER_cancel(), GST_forwarded_operation_timeout(), ForwardedOperationContext::next, OverlayConnectContext::next, occq_head, and ForwardedOperationContext::timeout_task.

Referenced by client_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

send_overlay_connect_success_msg()

static void send_overlay_connect_success_msg ( struct OverlayConnectContext *  occ )

static

FIXME.

Definition at line 654 of file gnunet-service-testbed_oc.c.

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

References OverlayConnectContext::client, env, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_CONNECT, Peer::id, LOG_DEBUG, msg, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, and OverlayConnectContext::peer.

Referenced by occ_cache_get_handle_core_cb(), and overlay_connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

overlay_connect_notify()

static void overlay_connect_notify ( void *  cls, const struct GNUNET_PeerIdentity *  new_peer  )

static

Function called to notify transport users that another peer connected to us.

Parameters

cls	closure
new_peer	the peer that connected

Definition at line 680 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ = cls;
  char *new_peer_str;
  char *other_peer_str;
 
  LOG_DEBUG ("Overlay connect notify\n");
  if (0 ==
      GNUNET_memcmp (new_peer,
                     &occ->peer_identity))
    return;
  new_peer_str = GNUNET_strdup (GNUNET_i2s (new_peer));
  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
  if (0 !=
      GNUNET_memcmp (new_peer,
                     &occ->other_peer_identity))
  {
    LOG_DEBUG ("Unexpected peer %s connected when expecting peer %s\n",
               new_peer_str,
               other_peer_str);
    GNUNET_free (new_peer_str);
    GNUNET_free (other_peer_str);
    return;
  }
  GNUNET_free (new_peer_str);
  LOG_DEBUG ("0x%llx: Peer %s connected to peer %s\n",
             (unsigned long long) occ->op_id,
             other_peer_str,
             GNUNET_i2s (&occ->peer_identity));
  GNUNET_free (other_peer_str);
  if (NULL != occ->send_hello_task)
  {
    GNUNET_SCHEDULER_cancel (occ->send_hello_task);
    occ->send_hello_task = NULL;
  }
  GNUNET_assert (NULL != occ->timeout_task);
  GNUNET_SCHEDULER_cancel (occ->timeout_task);
  occ->timeout_task = NULL;
  switch (occ->type)
  {
  case OCC_TYPE_LOCAL:
    cleanup_occ_lp2c (&occ->p2ctx.local);
    break;
 
  case OCC_TYPE_REMOTE_SLAVE:
  case OCC_TYPE_REMOTE_LATERAL:
    cleanup_occ_rp2c (&occ->p2ctx.remote);
    break;
  }
  GNUNET_free (occ->emsg);
  occ->emsg = NULL;
  send_overlay_connect_success_msg (occ);
  occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ,
                                                occ);
}

References cleanup_occ_lp2c(), cleanup_occ_rp2c(), OverlayConnectContext::cleanup_task, do_cleanup_occ(), OverlayConnectContext::emsg, GNUNET_assert, GNUNET_free, GNUNET_i2s(), GNUNET_memcmp, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_strdup, OverlayConnectContext::local, LOG_DEBUG, OCC_TYPE_LOCAL, OCC_TYPE_REMOTE_LATERAL, OCC_TYPE_REMOTE_SLAVE, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_identity, OverlayConnectContext::p2ctx, OverlayConnectContext::peer_identity, OverlayConnectContext::remote, OverlayConnectContext::send_hello_task, send_overlay_connect_success_msg(), OverlayConnectContext::timeout_task, and OverlayConnectContext::type.

Referenced by handle_overlay_connect(), and overlay_connect_get_config().

Here is the call graph for this function:

Here is the caller graph for this function:

occ_cache_get_handle_ats_occ_cb()

static void occ_cache_get_handle_ats_occ_cb ( void *  cls, struct GNUNET_CORE_Handle *  ch, struct GNUNET_TRANSPORT_CoreHandle *  th, struct GNUNET_ATS_ConnectivityHandle *  ac, const struct GNUNET_PeerIdentity *  my_identity, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Callback from cache with needed ATS handle set.

Parameters

cls	a struct OverlayConnectCtx *
ch	the handle to CORE. Can be NULL if it is not requested
th	the handle to TRANSPORT. Can be NULL if it is not requested
ac	the handle to ATS. Can be NULL if it is not requested
my_identity	the identity of our peer
cfg	configuration of the peer

Definition at line 749 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ = cls;
  struct LocalPeer2Context *lp2c;
 
  GNUNET_assert (OCC_TYPE_LOCAL == occ->type);
  GNUNET_assert (NULL != occ->timeout_task);
  GNUNET_free (occ->emsg);
  if (NULL == ac)
  {
    GNUNET_asprintf (&occ->emsg,
                     "0x%llx: Failed to connect to ATS of peer with id: %u",
                     (unsigned long long) occ->op_id,
                     occ->peer->id);
    GNUNET_SCHEDULER_cancel (occ->timeout_task);
    occ->timeout_task =
      GNUNET_SCHEDULER_add_now (&timeout_overlay_connect,
                                occ);
    return;
  }
  occ->emsg = NULL;
 
  GNUNET_asprintf (&occ->emsg,
                   "0x%llx: Timeout during GNUNET_ATS_connectivity_suggest() at peer %s",
                   (unsigned long long) 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);
}

References ac, ConnectivitySuggestContext::csh, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_ATS_connectivity_suggest(), GNUNET_free, GNUNET_i2s(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), Peer::id, OverlayConnectContext::local, OCC_TYPE_LOCAL, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_identity, OverlayConnectContext::p2ctx, OverlayConnectContext::peer, OverlayConnectContext::peer_identity, LocalPeer2Context::tcc, timeout_overlay_connect(), OverlayConnectContext::timeout_task, and OverlayConnectContext::type.

Referenced by occ_hello_sent_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

occ_cache_get_handle_ats_rocc_cb()

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

static

Callback from cache with needed ATS handle set.

Parameters

cls	a struct RemoteOverlayConnectCtx *
ch	the handle to CORE. Can be NULL if it is not requested
th	the handle to TRANSPORT. Can be NULL if it is not requested
ac	the handle to ATS. Can be NULL if it is not requested
my_identity	the identity of our peer

Definition at line 799 of file gnunet-service-testbed_oc.c.

{
  struct RemoteOverlayConnectCtx *rocc = cls;
 
  rocc->tcc.csh =
    GNUNET_ATS_connectivity_suggest (ac,
                                     &rocc->a_id,
                                     1);
}

References RemoteOverlayConnectCtx::a_id, ac, ConnectivitySuggestContext::csh, GNUNET_ATS_connectivity_suggest(), and RemoteOverlayConnectCtx::tcc.

Referenced by rocc_hello_sent_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

send_hello()

static void send_hello ( void *  cls )

static

Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to peer 1.

Task to offer HELLO of peer 1 to peer 2.

Parameters

cls	the OverlayConnectContext

If peer2 is local it is offered using its TRANSPORT connection; if remote the HELLO is sent remotely by using send_hello_thru_rocc()

Parameters

cls	the OverlayConnectContext

Definition at line 912 of file gnunet-service-testbed_oc.c.

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

References ConnectivitySuggestContext::cfg, GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_i2s(), GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TRANSPORT_offer_hello(), OverlayConnectContext::hello, OverlayConnectContext::local, LOG_DEBUG, occ_hello_sent_cb(), OCC_TYPE_LOCAL, LocalPeer2Context::ohh, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_identity, OverlayConnectContext::p2ctx, OverlayConnectContext::peer_identity, OverlayConnectContext::send_hello_task, send_hello_thru_rocc(), LocalPeer2Context::tcc, OverlayConnectContext::timeout_task, and OverlayConnectContext::type.

Referenced by p2_transport_connect(), and p2_transport_connect_cache_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

occ_hello_sent_cb()

static void occ_hello_sent_cb ( void *  cls )

static

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.

Parameters

cls	the overlay connect context

Definition at line 833 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ = cls;
  struct LocalPeer2Context *lp2c;
  struct Peer *peer2;
 
  GNUNET_assert (OCC_TYPE_LOCAL == occ->type);
  GNUNET_assert (NULL != occ->timeout_task);
  lp2c = &occ->p2ctx.local;
  lp2c->ohh = NULL;
 
  GNUNET_assert (NULL == occ->send_hello_task);
  GNUNET_free (occ->emsg);
 
  GNUNET_asprintf (&occ->emsg,
                   "0x%llx: Timeout while acquiring ATS of %s from cache",
                   (unsigned long long) 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);
}

References ConnectivitySuggestContext::cgh_p2_ats, Peer::details, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_i2s(), GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY, GST_peer_list, Peer::local, OverlayConnectContext::local, occ_cache_get_handle_ats_occ_cb(), OCC_TYPE_LOCAL, LocalPeer2Context::ohh, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::other_peer_identity, OverlayConnectContext::p2ctx, OverlayConnectContext::send_hello_task, LocalPeer2Context::tcc, OverlayConnectContext::timeout_task, and OverlayConnectContext::type.

Referenced by send_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

send_hello_thru_rocc()

static void send_hello_thru_rocc ( struct OverlayConnectContext *  occ )

static

Sends the HELLO of peer1 to peer2's controller through remote overlay connect request.

Parameters

occ	the overlay connect context. Its type must be either OCC_TYPE_REMOTE_SLAVE or OCC_TYPE_REMOTE_LATERAL

Definition at line 869 of file gnunet-service-testbed_oc.c.

{
  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",
    (unsigned long long) occ->op_id,
    GNUNET_i2s (&occ->peer_identity),
    ntohs (occ->hello->size),
    other_peer_str);
  GNUNET_free (other_peer_str);
  hello_size = ntohs (occ->hello->size);
  msize = sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage)
          + hello_size;
  msg = GNUNET_malloc (msize);
  msg->header.type =
    htons (GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT);
  msg->header.size = htons (msize);
  msg->peer = htonl (occ->other_peer_id);
  msg->operation_id = GNUNET_htonll (occ->op_id);
  msg->peer_identity = occ->peer_identity;
  GNUNET_memcpy (msg->hello,
                 occ->hello,
                 hello_size);
  GNUNET_TESTBED_queue_message_ (occ->p2ctx.remote.p2c,
                                 &msg->header);
}

References GNUNET_assert, GNUNET_free, GNUNET_htonll(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT, GNUNET_strdup, GNUNET_TESTBED_queue_message_(), OverlayConnectContext::hello, LOG_DEBUG, msg, OCC_TYPE_LOCAL, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::other_peer_identity, RemotePeer2Context::p2c, OverlayConnectContext::p2ctx, OverlayConnectContext::peer_identity, OverlayConnectContext::remote, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and OverlayConnectContext::type.

Referenced by send_hello().

Here is the call graph for this function:

Here is the caller graph for this function:

p2_transport_connect_cache_callback()

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

static

Callback from cache with needed handles set.

Parameters

cls	the closure passed to GST_cache_get_handle_transport()
ch	the handle to CORE. Can be NULL if it is not requested
th	the handle to TRANSPORT. Can be NULL if it is not requested
ac	the handle to ATS. Can be NULL if it is not requested
ignore_	peer identity which is ignored in this callback
cfg	configuration of the peer

Definition at line 963 of file gnunet-service-testbed_oc.c.

{
  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",
                     (unsigned long long) occ->op_id,
                     GNUNET_i2s (&occ->other_peer_identity));
    GNUNET_SCHEDULER_cancel (occ->timeout_task);
    occ->timeout_task =
      GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
    return;
  }
  occ->p2ctx.local.tcc.th_ = th;
  occ->p2ctx.local.tcc.cfg = cfg;
  GNUNET_asprintf (&occ->emsg,
                   "0x%llx: Timeout while offering HELLO to %s",
                   (unsigned long long) occ->op_id,
                   GNUNET_i2s (&occ->other_peer_identity));
  occ->send_hello_task = GNUNET_SCHEDULER_add_now (&send_hello, occ);
}

References cfg, ConnectivitySuggestContext::cfg, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_i2s(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), OverlayConnectContext::local, OCC_TYPE_LOCAL, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_identity, OverlayConnectContext::p2ctx, send_hello(), OverlayConnectContext::send_hello_task, LocalPeer2Context::tcc, ConnectivitySuggestContext::th_, timeout_overlay_connect(), OverlayConnectContext::timeout_task, and OverlayConnectContext::type.

Referenced by p2_transport_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

p2_transport_connect()

static void p2_transport_connect ( struct OverlayConnectContext *  occ )

static

Connects to the transport of the other peer if it is a local peer and schedules the send hello task.

Parameters

occ	the overlay connect context

Definition at line 1002 of file gnunet-service-testbed_oc.c.

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

References OverlayConnectContext::cgh_p1th, ConnectivitySuggestContext::cgh_p2_th, Peer::details, OverlayConnectContext::emsg, OverlayConnectContext::ghh, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_TRANSPORT, GST_peer_list, OverlayConnectContext::hello, Peer::local, OverlayConnectContext::local, OCC_TYPE_LOCAL, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::other_peer_identity, OverlayConnectContext::p1th_, p2_transport_connect_cache_callback(), OverlayConnectContext::p2ctx, send_hello(), OverlayConnectContext::send_hello_task, LocalPeer2Context::tcc, and OverlayConnectContext::type.

Referenced by hello_update_cb(), and occ_cache_get_handle_core_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

test_address()

static int test_address ( void *  cls, const struct GNUNET_HELLO_Address *  address, struct GNUNET_TIME_Absolute  expiration  )

static

Test for checking whether HELLO message is empty.

Parameters

cls	empty flag to set
address	the HELLO
expiration	expiration of the HELLO

Returns

GNUNET_OK

Definition at line 1044 of file gnunet-service-testbed_oc.c.

{
  int *empty = cls;
 
  *empty = GNUNET_NO;
  return GNUNET_OK;
}

References GNUNET_NO, and GNUNET_OK.

Referenced by GNUNET_ATS_solver_generate_property_start(), hello_update_cb(), and set_prop_task().

Here is the caller graph for this function:

hello_update_cb()

static void hello_update_cb ( void *  cls, const struct GNUNET_MessageHeader *  hello  )

static

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

Parameters

cls	closure
hello	our updated HELLO

Definition at line 1064 of file gnunet-service-testbed_oc.c.

{
  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",
               (unsigned long long) occ->op_id,
               GNUNET_i2s (&occ->peer_identity));
    return;
  }
  LOG_DEBUG ("0x%llx: Received HELLO of %s\n",
             (unsigned long long) occ->op_id,
             GNUNET_i2s (&occ->peer_identity));
  occ->hello = GNUNET_malloc (msize);
  GST_cache_add_hello (occ->peer->id, hello);
  GNUNET_memcpy (occ->hello, hello, msize);
  GNUNET_TRANSPORT_hello_get_cancel (occ->ghh);
  occ->ghh = NULL;
  GST_connection_pool_get_handle_done (occ->cgh_p1th);
  occ->cgh_p1th = NULL;
  occ->p1th_ = NULL;
  GNUNET_free (occ->emsg);
  occ->emsg = NULL;
  p2_transport_connect (occ);
}

References OverlayConnectContext::cgh_p1th, OverlayConnectContext::emsg, OverlayConnectContext::ghh, GNUNET_free, GNUNET_HELLO_iterate_addresses(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_TRANSPORT_hello_get_cancel(), GNUNET_YES, GST_cache_add_hello(), GST_connection_pool_get_handle_done(), OverlayConnectContext::hello, Peer::id, LOG_DEBUG, OverlayConnectContext::op_id, OverlayConnectContext::p1th_, p2_transport_connect(), OverlayConnectContext::peer, OverlayConnectContext::peer_identity, GNUNET_MessageHeader::size, and test_address().

Referenced by p1_transport_connect_cache_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

p1_transport_connect_cache_callback()

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

static

Callback from cache with needed handles set.

Parameters

cls	the closure passed to GST_cache_get_handle_transport()
ch	the handle to CORE. Can be NULL if it is not requested
th	the handle to TRANSPORT. Can be NULL if it is not requested
ac	the handle to ATS. Can be NULL if it is not requested
ignore_	peer identity which is ignored in this callback

Definition at line 1111 of file gnunet-service-testbed_oc.c.

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

References cfg, OverlayConnectContext::cgh_p1th, OverlayConnectContext::emsg, OverlayConnectContext::ghh, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_i2s(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_AC_ANY, GNUNET_TRANSPORT_hello_get(), hello_update_cb(), OverlayConnectContext::op_id, OverlayConnectContext::p1th_, OverlayConnectContext::peer_identity, timeout_overlay_connect(), and OverlayConnectContext::timeout_task.

Referenced by occ_cache_get_handle_core_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

occ_cache_get_handle_core_cb()

static void occ_cache_get_handle_core_cb ( void *  cls, struct GNUNET_CORE_Handle *  ch, struct GNUNET_TRANSPORT_CoreHandle *  th, struct GNUNET_ATS_ConnectivityHandle *  ac, const struct GNUNET_PeerIdentity *  my_identity, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Callback from cache with needed CORE handle set.

Parameters

cls	the closure passed to GST_cache_get_handle_transport()
ch	the handle to CORE. Can be NULL if it is not requested
th	the handle to TRANSPORT. Can be NULL if it is not requested
ac	the handle to ATS. Can be NULL if it is not requested
my_identity	the identity of our peer

Definition at line 1158 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ = cls;
  const struct GNUNET_MessageHeader *hello;
 
  GNUNET_assert (NULL != occ->timeout_task);
  GNUNET_free (occ->emsg);
  if ((NULL == ch) || (NULL == my_identity))
  {
    GNUNET_asprintf (&occ->emsg,
                     "0x%llx: Failed to connect to CORE of peer with "
                     "id: %u",
                     (unsigned long long) 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;
  occ->peer_identity = *my_identity;
  if (NULL !=
      GNUNET_CORE_get_mq (ch,
                          &occ->other_peer_identity))
  {
    LOG_DEBUG ("0x%llx: Target peer %s already connected\n",
               (unsigned long long) occ->op_id,
               GNUNET_i2s (&occ->other_peer_identity));
    LOG_DEBUG ("0x%llx: Target peer %s connected\n",
               (unsigned long long) occ->op_id,
               GNUNET_i2s (&occ->peer_identity));
    GNUNET_SCHEDULER_cancel (occ->timeout_task);
    occ->timeout_task = NULL;
    send_overlay_connect_success_msg (occ);
    occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ);
    return;
  }
  LOG_DEBUG ("0x%llx: Acquiring HELLO of peer %s\n",
             (unsigned long long) 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",
               (unsigned long long) 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",
                   (unsigned long long) occ->op_id,
                   GNUNET_i2s (&occ->peer_identity));
  occ->cgh_p1th =
    GST_connection_pool_get_handle (occ->peer->id,
                                    occ->peer->details.local.cfg,
                                    GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
                                    p1_transport_connect_cache_callback,
                                    occ,
                                    NULL, NULL, NULL);
}

References OverlayConnectContext::cgh_p1th, ch, OverlayConnectContext::cleanup_task, Peer::details, do_cleanup_occ(), OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_copy_message(), GNUNET_CORE_get_mq(), GNUNET_free, GNUNET_i2s(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GST_cache_lookup_hello(), GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_TRANSPORT, OverlayConnectContext::hello, Peer::id, Peer::local, LOG_DEBUG, my_identity, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_identity, p1_transport_connect_cache_callback(), p2_transport_connect(), OverlayConnectContext::peer, OverlayConnectContext::peer_identity, send_overlay_connect_success_msg(), timeout_overlay_connect(), and OverlayConnectContext::timeout_task.

Referenced by handle_overlay_connect(), and overlay_connect_get_config().

Here is the call graph for this function:

Here is the caller graph for this function:

overlay_connect_get_config()

static void overlay_connect_get_config ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Callback to be called when forwarded get peer config operation as part of overlay connect is successful.

Connection to Peer 1's core is made and is checked for new connection from peer 2

Parameters

cls	ForwardedOperationContext
msg	the peer create success message

Definition at line 1236 of file gnunet-service-testbed_oc.c.

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

References OverlayConnectContext::cgh_ch, Peer::details, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_CORE, Peer::id, Peer::local, msg, occ_cache_get_handle_core_cb(), OCC_TYPE_LOCAL, OverlayConnectContext::op_id, RemotePeer2Context::opc, OverlayConnectContext::other_peer_identity, overlay_connect_notify(), OverlayConnectContext::p2ctx, OverlayConnectContext::peer, GNUNET_TESTBED_PeerConfigurationInformationMessage::peer_identity, OverlayConnectContext::remote, timeout_overlay_connect(), OverlayConnectContext::timeout_task, GNUNET_MessageHeader::type, and OverlayConnectContext::type.

Referenced by p2_controller_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

host_registration_comp()

static void host_registration_comp ( void *  cls, const char *  emsg  )

static

Callback which will be called after a host registration succeeded or failed.

Parameters

cls	the RegisteredHostContext
emsg	the error message; NULL if host registration is successful

Definition at line 1281 of file gnunet-service-testbed_oc.c.

{
  struct RegisteredHostContext *rhc = cls;
 
  rhc->state = RHC_DONE;
  GST_process_next_focc (rhc);
}

References GST_process_next_focc(), RegisteredHostContext::RHC_DONE, and RegisteredHostContext::state.

Referenced by register_host().

Here is the call graph for this function:

Here is the caller graph for this function:

reghost_match_iterator()

static int reghost_match_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator to match a registered host context.

Parameters

cls	pointer 2 pointer of RegisteredHostContext
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 1301 of file gnunet-service-testbed_oc.c.

{
  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;
}

Referenced by register_host().

Here is the caller graph for this function:

hash_hosts()

static struct GNUNET_HashCode hash_hosts ( struct GNUNET_TESTBED_Host *  reg_host, struct GNUNET_TESTBED_Host *  host  )

static

Function to generate the hashcode corresponding to a RegisteredHostContext.

Parameters

reg_host	the host which is being registered in RegisteredHostContext
host	the host of the controller which has to connect to the above rhost

Returns

the hashcode

Definition at line 1301 of file gnunet-service-testbed_oc.c.

{
  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;
}

References GNUNET_free, GNUNET_NO, GNUNET_YES, RegisteredHostContext::host, RegisteredHostContext::reg_host, and value.

Referenced by register_host().

Here is the caller graph for this function:

register_host()

static struct RegisteredHostContext* register_host ( struct Slave *  slave, struct GNUNET_TESTBED_Host *  host  )

static

Checks if the given host is registered at the given slave.

Parameters

slave	the slave where registration has to be checked. The check is actually done through a locally maintained hashmap. No communication with the slave is involved.
host	the host to register

Returns

If the given host is not registered already or the registration is pending, it returns the registration context. Any overlay connects to be forwarded should be queued in the context so that they can be executed when the registration is completed. If the given host is already registered, NULL is returned.

Definition at line 1353 of file gnunet-service-testbed_oc.c.

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

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_new, GNUNET_NO, GNUNET_SYSERR, GST_host_list, GST_queue_host_registration(), hash_hosts(), RegisteredHostContext::host, Slave::host_id, host_registration_comp(), RegisteredHostContext::reg_host, Slave::reghost_map, reghost_match_iterator(), RegisteredHostContext::RHC_DONE, RegisteredHostContext::RHC_INIT, and RegisteredHostContext::state.

Referenced by forward_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

forward_overlay_connect()

static void forward_overlay_connect ( const struct GNUNET_TESTBED_OverlayConnectMessage *  msg, struct GNUNET_SERVICE_Client *  client  )

static

Forwards the overlay connect request to a slave controller.

Before forwarding, any hosts which are needed to be known by the slave controller to execute the overlay connect request are registered at slave.

Parameters

msg	the overlay connect request message to be forwarded
client	the client to which the status of the forwarded request has to be notified

Definition at line 1409 of file gnunet-service-testbed_oc.c.

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

References ForwardedOperationContext::client, ForwardedOverlayConnectContext::client, GNUNET_TESTBED_Peer::controller, Route::dest, RegisteredHostContext::focc_dll_head, RegisteredHostContext::focc_dll_tail, fopcq_head, fopcq_tail, forward, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_copy_message(), GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_YES, GST_find_dest_route(), GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_host_list, GST_peer_list, GST_timeout, LOG_DEBUG, msg, OP_OVERLAY_CONNECT, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, ForwardedOverlayConnectContext::operation_id, ForwardedOverlayConnectContext::orig_msg, peer, ForwardedOverlayConnectContext::peer1, ForwardedOverlayConnectContext::peer2, ForwardedOverlayConnectContext::peer2_host_id, register_host(), ForwardedOverlayConnectContext::rhc, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, VALID_HOST_ID, and VALID_PEER_ID.

Referenced by handle_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

p2_controller_connect_cb()

static void p2_controller_connect_cb ( void *  cls, struct GNUNET_TESTBED_Controller *  c  )

static

Callback called when a connection to the controller of peer2 has been established.

Parameters

cls	the overlay connect contexts
c	handle to the controller connection

Definition at line 1492 of file gnunet-service-testbed_oc.c.

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

References OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION, GNUNET_TESTBED_forward_operation_msg_(), GNUNET_TESTBED_PeerGetConfigurationMessage::header, RemotePeer2Context::ncn, OCC_TYPE_LOCAL, OverlayConnectContext::op_id, RemotePeer2Context::opc, GNUNET_TESTBED_PeerGetConfigurationMessage::operation_id, OverlayConnectContext::other_peer_id, overlay_connect_get_config(), RemotePeer2Context::p2c, OverlayConnectContext::p2ctx, GNUNET_TESTBED_PeerGetConfigurationMessage::peer_id, OverlayConnectContext::remote, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and OverlayConnectContext::type.

Referenced by handle_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_overlay_connect()

void handle_overlay_connect	(	void *	cls,
		const struct GNUNET_TESTBED_OverlayConnectMessage *	msg
	)

Handler for GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1531 of file gnunet-service-testbed_oc.c.

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

References OverlayConnectContext::cgh_ch, OverlayConnectContext::client, Peer::details, OverlayConnectContext::emsg, forward_overlay_connect(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TESTING_peer_get_identity(), GNUNET_YES, GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_CORE, GST_create_neighbour(), GST_get_neighbour(), GST_host_list, GST_neighbour_get_connection(), GST_peer_list, GST_timeout, Peer::id, Peer::local, LOG, LOG_DEBUG, msg, RemotePeer2Context::ncn, occ_cache_get_handle_core_cb(), OCC_TYPE_LOCAL, OCC_TYPE_REMOTE_LATERAL, OCC_TYPE_REMOTE_SLAVE, occq_head, occq_tail, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::other_peer_identity, overlay_connect_notify(), p2_controller_connect_cb(), RemotePeer2Context::p2c, OverlayConnectContext::p2ctx, RemotePeer2Context::p2n, OverlayConnectContext::peer, peer, Peer::reference_cnt, Peer::remote, OverlayConnectContext::remote, timeout_overlay_connect(), OverlayConnectContext::timeout_task, OverlayConnectContext::type, VALID_HOST_ID, and VALID_PEER_ID.

Here is the call graph for this function:

cleanup_rocc()

static void cleanup_rocc ( struct RemoteOverlayConnectCtx *  rocc )

static

Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.

Parameters

rocc	the RemoteOverlayConnectCtx

Definition at line 1678 of file gnunet-service-testbed_oc.c.

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

References RemoteOverlayConnectCtx::attempt_connect_task_id, ConnectivitySuggestContext::cgh_p2_ats, ConnectivitySuggestContext::cgh_p2_th, ConnectivitySuggestContext::csh, Peer::destroy_flag, GNUNET_assert, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_offer_hello_cancel(), GNUNET_YES, GST_connection_pool_get_handle_done(), GST_destroy_peer(), RemoteOverlayConnectCtx::hello, LOG_DEBUG, RemoteOverlayConnectCtx::ohh, RemoteOverlayConnectCtx::op_id, RemoteOverlayConnectCtx::peer, Peer::reference_cnt, roccq_head, roccq_tail, RemoteOverlayConnectCtx::tcc, and RemoteOverlayConnectCtx::timeout_rocc_task_id.

Referenced by cache_transport_peer_connect_notify(), GST_free_roccq(), rocc_cache_get_handle_transport_cb(), and timeout_rocc_task().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_rocc_task()

static void timeout_rocc_task ( void *  cls )

static

Task to timeout rocc and cleanit up.

Parameters

cls	the RemoteOverlayConnectCtx

Definition at line 1711 of file gnunet-service-testbed_oc.c.

{
  struct RemoteOverlayConnectCtx *rocc = cls;
 
  GNUNET_assert (rocc->timeout_rocc_task_id != NULL);
  rocc->timeout_rocc_task_id = NULL;
  LOG_DEBUG ("0x%llx: rocc timed out\n",
             (unsigned long long) rocc->op_id);
  cleanup_rocc (rocc);
}

References cleanup_rocc(), GNUNET_assert, LOG_DEBUG, RemoteOverlayConnectCtx::op_id, and RemoteOverlayConnectCtx::timeout_rocc_task_id.

Referenced by handle_remote_overlay_connect(), and rocc_cache_get_handle_transport_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

cache_transport_peer_connect_notify()

static void cache_transport_peer_connect_notify ( void *  cls, const struct GNUNET_PeerIdentity *  new_peer  )

static

Function called to notify transport users that another peer connected to us.

Parameters

cls	the RemoteOverlayConnectContext
new_peer	the peer that connected

Definition at line 1731 of file gnunet-service-testbed_oc.c.

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

References RemoteOverlayConnectCtx::a_id, cleanup_rocc(), GNUNET_assert, GNUNET_i2s(), LOG_DEBUG, and RemoteOverlayConnectCtx::op_id.

Referenced by handle_remote_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

attempt_connect_task()

static void attempt_connect_task ( void *  cls )

static

Task to offer the HELLO message to the peer and ask it to connect to the peer whose identity is in RemoteOverlayConnectCtx.

Parameters

cls	the RemoteOverlayConnectCtx

Definition at line 1792 of file gnunet-service-testbed_oc.c.

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

References RemoteOverlayConnectCtx::a_id, RemoteOverlayConnectCtx::attempt_connect_task_id, ConnectivitySuggestContext::cfg, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_i2s(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TRANSPORT_offer_hello(), RemoteOverlayConnectCtx::hello, Peer::id, LOG_DEBUG, RemoteOverlayConnectCtx::ohh, RemoteOverlayConnectCtx::op_id, RemoteOverlayConnectCtx::peer, rocc_hello_sent_cb(), and RemoteOverlayConnectCtx::tcc.

Referenced by rocc_cache_get_handle_transport_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

rocc_hello_sent_cb()

static void rocc_hello_sent_cb ( void *  cls )

static

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.

Parameters

cls	the overlay connect context

Definition at line 1766 of file gnunet-service-testbed_oc.c.

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

References RemoteOverlayConnectCtx::a_id, RemoteOverlayConnectCtx::attempt_connect_task_id, ConnectivitySuggestContext::cgh_p2_ats, Peer::details, GNUNET_assert, GNUNET_i2s(), GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY, Peer::id, Peer::local, LOG_DEBUG, occ_cache_get_handle_ats_rocc_cb(), RemoteOverlayConnectCtx::ohh, RemoteOverlayConnectCtx::op_id, RemoteOverlayConnectCtx::peer, and RemoteOverlayConnectCtx::tcc.

Referenced by attempt_connect_task().

Here is the call graph for this function:

Here is the caller graph for this function:

rocc_cache_get_handle_transport_cb()

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

static

Callback from cache with needed handles set.

Parameters

cls	the closure passed to GST_cache_get_handle_transport()
ch	the handle to CORE. Can be NULL if it is not requested
th	the handle to TRANSPORT. Can be NULL if it is not requested
ac	the handle to ATS. Can be NULL if it is not requested
ignore_	peer identity which is ignored in this callback

Definition at line 1828 of file gnunet-service-testbed_oc.c.

{
  struct RemoteOverlayConnectCtx *rocc = cls;
 
  if (NULL == th)
  {
    rocc->timeout_rocc_task_id =
      GNUNET_SCHEDULER_add_now (&timeout_rocc_task, rocc);
    return;
  }
  rocc->tcc.th_ = th;
  rocc->tcc.cfg = cfg;
  if (NULL !=
      GNUNET_TRANSPORT_core_get_mq (rocc->tcc.th_,
                                    &rocc->a_id))
  {
    LOG_DEBUG ("0x%llx: Target peer %s already connected to local peer: %u\n",
               (unsigned long long) 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);
}

References RemoteOverlayConnectCtx::a_id, attempt_connect_task(), RemoteOverlayConnectCtx::attempt_connect_task_id, cfg, ConnectivitySuggestContext::cfg, cleanup_rocc(), GNUNET_i2s(), GNUNET_SCHEDULER_add_now(), GNUNET_TRANSPORT_core_get_mq(), Peer::id, LOG_DEBUG, RemoteOverlayConnectCtx::op_id, RemoteOverlayConnectCtx::peer, RemoteOverlayConnectCtx::tcc, ConnectivitySuggestContext::th_, timeout_rocc_task(), and RemoteOverlayConnectCtx::timeout_rocc_task_id.

Referenced by handle_remote_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

check_remote_overlay_connect()

int check_remote_overlay_connect	(	void *	cls,
		const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *	msg
	)

Check GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 1870 of file gnunet-service-testbed_oc.c.

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

References GNUNET_break, GNUNET_break_op, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_OK, GNUNET_SYSERR, GST_peer_list, GST_peer_list_size, msg, peer_id, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

handle_remote_overlay_connect()

void handle_remote_overlay_connect	(	void *	cls,
		const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *	msg
	)

Handler for GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1909 of file gnunet-service-testbed_oc.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct RemoteOverlayConnectCtx *rocc;
  struct Peer *peer;
  struct GNUNET_PeerIdentity pid;
  static char pid_str[16];
  uint32_t peer_id;
  uint16_t hsize;
 
  hsize = ntohs (msg->hello->size);
  peer_id = ntohl (msg->peer);
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    struct GNUNET_MessageHeader *msg2;
 
    msg2 = GNUNET_copy_message (&msg->header);
    GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller,
                                   msg2);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  rocc = GNUNET_new (struct RemoteOverlayConnectCtx);
  rocc->op_id = GNUNET_ntohll (msg->operation_id);
  GNUNET_CONTAINER_DLL_insert_tail (roccq_head,
                                    roccq_tail,
                                    rocc);
  rocc->a_id = msg->peer_identity;
  GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
                                    &pid);
  (void) GNUNET_strlcpy (pid_str,
                         GNUNET_i2s (&pid),
                         sizeof(pid_str));
  LOG_DEBUG (
    "0x%llx: Remote overlay connect %s to peer %s with hello size: %u\n",
    (unsigned long long) rocc->op_id,
    pid_str,
    GNUNET_i2s (&rocc->a_id),
    hsize);
  rocc->peer = peer;
  rocc->peer->reference_cnt++;
  rocc->hello = GNUNET_malloc (hsize);
  GNUNET_memcpy (rocc->hello,
                 msg->hello,
                 hsize);
  rocc->tcc.cgh_p2_th =
    GST_connection_pool_get_handle (peer_id,
                                    rocc->peer->details.local.cfg,
                                    GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
                                    &rocc_cache_get_handle_transport_cb,
                                    rocc,
                                    &rocc->a_id,
                                    &cache_transport_peer_connect_notify,
                                    rocc);
  rocc->timeout_rocc_task_id =
    GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                  &timeout_rocc_task,
                                  rocc);
  GNUNET_SERVICE_client_continue (client);
}

References RemoteOverlayConnectCtx::a_id, cache_transport_peer_connect_notify(), ConnectivitySuggestContext::cgh_p2_th, GNUNET_TESTBED_Peer::controller, Peer::details, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_copy_message(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_strlcpy(), GNUNET_TESTBED_queue_message_(), GNUNET_TESTING_peer_get_identity(), GNUNET_YES, GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_TRANSPORT, GST_peer_list, GST_timeout, RemoteOverlayConnectCtx::hello, Peer::local, LOG_DEBUG, msg, RemoteOverlayConnectCtx::op_id, RemoteOverlayConnectCtx::peer, peer, peer_id, pid, Peer::reference_cnt, rocc_cache_get_handle_transport_cb(), roccq_head, roccq_tail, GNUNET_MessageHeader::size, RemoteOverlayConnectCtx::tcc, timeout_rocc_task(), and RemoteOverlayConnectCtx::timeout_rocc_task_id.

Here is the call graph for this function:

GST_free_occq()

void GST_free_occq

(

void

)

Clears all pending overlay connect contexts in queue.

Definition at line 1978 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ;
 
  while (NULL != (occ = occq_head))
    cleanup_occ (occ);
}

References cleanup_occ(), and occq_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_free_roccq()

void GST_free_roccq

(

void

)

Clears all pending remote overlay connect contexts in queue.

Definition at line 1991 of file gnunet-service-testbed_oc.c.

{
  struct RemoteOverlayConnectCtx *rocc;
 
  while (NULL != (rocc = roccq_head))
    cleanup_rocc (rocc);
}

References cleanup_rocc(), and roccq_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

occq_head

struct OverlayConnectContext* occq_head

static

DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.

Definition at line 332 of file gnunet-service-testbed_oc.c.

Referenced by cleanup_occ(), GST_free_occq(), GST_notify_client_disconnect_oc(), and handle_overlay_connect().

occq_tail

struct OverlayConnectContext* occq_tail

static

DLL tail for OverlayConnectContext DLL.

Definition at line 337 of file gnunet-service-testbed_oc.c.

Referenced by cleanup_occ(), and handle_overlay_connect().

roccq_head

struct RemoteOverlayConnectCtx* roccq_head

static

DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown.

Definition at line 343 of file gnunet-service-testbed_oc.c.

Referenced by cleanup_rocc(), GST_free_roccq(), and handle_remote_overlay_connect().

roccq_tail

struct RemoteOverlayConnectCtx* roccq_tail

static

DLL tail for RequectOverlayConnectContext DLL.

Definition at line 348 of file gnunet-service-testbed_oc.c.

Referenced by cleanup_rocc(), and handle_remote_overlay_connect().