GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions | Variables
gnunet-service-testbed_oc.c File Reference

code for handling overlay connect operations More...

#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 successfull. 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 cleaing 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 successfull. 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 RegisteredHostContextregister_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 OverlayConnectContextoccq_head
 DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown. More...
 
static struct OverlayConnectContextoccq_tail
 DLL tail for OverlayConnectContext DLL. More...
 
static struct RemoteOverlayConnectCtxroccq_head
 DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown. More...
 
static struct RemoteOverlayConnectCtxroccq_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 37 of file gnunet-service-testbed_oc.c.

Referenced by handle_overlay_connect().

◆ 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
peerthe peer to check

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

Referenced by cleanup_occ().

Enumeration Type Documentation

◆ 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 77 of file gnunet-service-testbed_oc.c.

78 {
84 
90 
96 };
Type to be used when the first peer is local and the other peer is on a controller which is not start...
This type is used if the overlay connection is local i.e.
Type to be used when the first peer is local and the other peer is on a slave controller started by u...

Function Documentation

◆ GST_cleanup_focc()

void GST_cleanup_focc ( struct ForwardedOverlayConnectContext focc)

Cleans up ForwardedOverlayConnectContext.

Parameters
foccthe ForwardedOverlayConnectContext to cleanup

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

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

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

357 {
358  struct RegisteredHostContext *rhc = focc->rhc;
359 
361  rhc->focc_dll_tail,
362  focc);
364  GNUNET_free (focc);
365 }
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
This context information will be created for each host that is registered at slave controllers during...
struct GNUNET_MessageHeader * orig_msg
A copy of the original overlay connect message.
struct ForwardedOverlayConnectContext * focc_dll_tail
Tail of the ForwardedOverlayConnectContext DLL.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct RegisteredHostContext * rhc
Which host does this FOCC belong to?
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe struct ForwardedOperationContext

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

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

Referenced by GST_process_next_focc().

375 {
376  struct ForwardedOperationContext *fopc = cls;
377  struct RegisteredHostContext *rhc;
378  struct ForwardedOverlayConnectContext *focc;
379 
380  fopc->timeout_task = NULL;
381  rhc = fopc->cls;
382  focc = rhc->focc_dll_head;
383  LOG_DEBUG ("Overlay linking between peers %u and %u failed\n",
384  focc->peer1,
385  focc->peer2);
386  GST_cleanup_focc (focc);
388  if (NULL != rhc->focc_dll_head)
389  GST_process_next_focc (rhc);
390 }
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
This context information will be created for each host that is registered at slave controllers during...
void GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
Cleans up ForwardedOverlayConnectContext.
void GST_forwarded_operation_timeout(void *cls)
Task to free resources when forwarded operation has been timed out.
uint32_t peer2
The id of peer 2.
Context information to used during operations which forward the overlay connect message.
void * cls
Closure pointer.
void GST_process_next_focc(struct RegisteredHostContext *rhc)
Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext.
Context information for operations forwarded to subcontrollers.
#define LOG_DEBUG(...)
Debug logging shorthand.
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 successfull.

We have to relay the reply msg back to the client

Parameters
clsForwardedOperationContext
msgthe peer create success message

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

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

Referenced by GST_process_next_focc().

404 {
405  struct ForwardedOperationContext *fopc = cls;
406  struct RegisteredHostContext *rhc;
407  struct ForwardedOverlayConnectContext *focc;
408 
409  rhc = fopc->cls;
411  focc = rhc->focc_dll_head;
412  GST_cleanup_focc (focc);
413  if (NULL != rhc->focc_dll_head)
414  GST_process_next_focc (rhc);
415 }
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
This context information will be created for each host that is registered at slave controllers during...
void GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
Cleans up ForwardedOverlayConnectContext.
void GST_forwarded_operation_reply_relay(void *cls, const struct GNUNET_MessageHeader *msg)
Callback to relay the reply msg of a forwarded operation back to the client.
Context information to used during operations which forward the overlay connect message.
void * cls
Closure pointer.
void GST_process_next_focc(struct RegisteredHostContext *rhc)
Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext.
Context information for operations forwarded to subcontrollers.
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
rhcthe RegisteredHostContext

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

References ForwardedOperationContext::client, ForwardedOverlayConnectContext::client, ForwardedOperationContext::cls, Slave::controller, Peer::details, 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, Peer::is_remote, OP_OVERLAY_CONNECT, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, ForwardedOverlayConnectContext::operation_id, ForwardedOverlayConnectContext::orig_msg, peer, ForwardedOverlayConnectContext::peer1, Peer::remote, 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().

425 {
426  struct ForwardedOperationContext *fopc;
427  struct ForwardedOverlayConnectContext *focc;
428  struct Peer *peer;
429  struct Slave *slave;
430 
431  focc = rhc->focc_dll_head;
432  GNUNET_assert (NULL != focc);
433  GNUNET_assert (RHC_DONE == rhc->state);
435  peer = GST_peer_list[focc->peer1];
437  GNUNET_assert (NULL != (slave = peer->details.remote.slave));
438  fopc = GNUNET_new (struct ForwardedOperationContext);
439  fopc->client = focc->client;
440  fopc->operation_id = focc->operation_id;
441  fopc->cls = rhc;
442  fopc->type = OP_OVERLAY_CONNECT;
443  fopc->opc =
445  focc->operation_id,
446  focc->orig_msg,
448  fopc);
449  GNUNET_free (focc->orig_msg);
450  focc->orig_msg = NULL;
452  &
454  fopc);
456  fopcq_tail,
457  fopc);
458 }
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
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...
int is_remote
Is this peer locally created?
struct GNUNET_MessageHeader * orig_msg
A copy of the original overlay connect message.
static void forwarded_overlay_connect_timeout(void *cls)
Timeout task for cancelling a forwarded overlay connect connect.
struct GNUNET_SERVICE_Client * client
The client handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define VALID_PEER_ID(id)
Condition to check if peer id is valid.
struct OperationContext * opc
The generated operation context.
struct Peer ** GST_peer_list
A list of peers we know about.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Structure representing a connected(directly-linked) controller.
struct Peer::@66::@68 remote
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
struct ForwardedOperationContext * fopcq_head
DLL head for forwarded operation contexts.
uint64_t operation_id
The id of the operation which created this context information.
enum OperationType type
The type of the operation which is forwarded.
Context information to used during operations which forward the overlay connect message.
union Peer::@66 details
enum RegisteredHostContext::RHCState state
void * cls
Closure pointer.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Overlay connection operation.
Definition: testbed_api.h:79
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct OperationContext * GNUNET_TESTBED_forward_operation_msg_(struct GNUNET_TESTBED_Controller *controller, uint64_t operation_id, const struct GNUNET_MessageHeader *msg, GNUNET_MQ_MessageCallback cc, void *cc_cls)
Sends the given message as an operation.
Definition: testbed_api.c:1369
struct ForwardedOperationContext * fopcq_tail
DLL tail for forwarded operation contexts.
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
struct GNUNET_SERVICE_Client * client
The client to which we have to reply.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
uint64_t operation_id
The id of the operation that has been forwarded.
#define GNUNET_YES
Definition: gnunet_common.h:77
Context information for operations forwarded to subcontrollers.
#define GNUNET_free(ptr)
Wrapper around free.
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
lp2cthe local peer2 context information

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

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().

468 {
469  if (NULL != lp2c->ohh)
470  {
472  lp2c->ohh = NULL;
473  }
474  if (NULL != lp2c->tcc.cgh_p2_th)
475  {
477  lp2c->tcc.cgh_p2_th = NULL;
478  }
479  if (NULL != lp2c->tcc.cgh_p2_ats)
480  {
482  lp2c->tcc.cgh_p2_ats = NULL;
483  }
484  if (NULL != lp2c->tcc.csh)
485  {
487  lp2c->tcc.csh = NULL;
488  }
489 }
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering the HELLO of the first peer to the second peer.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_ATS_ConnectivitySuggestHandle * csh
The ATS handle for the connectivity suggestion.
struct GST_ConnectionPool_GetHandle * cgh_p2_th
The GetCacheHandle for the peer2's transport handle (used to offer the HELLO to the peer)...
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
struct GST_ConnectionPool_GetHandle * cgh_p2_ats
The GetCacheHandle for the peer2's ATS handle.
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
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
rp2cthe remote peer2 context information

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

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().

500 {
501  if (NULL != rp2c->opc)
502  {
504  rp2c->opc = NULL;
505  }
506  if (NULL != rp2c->ncn)
507  {
509  rp2c->ncn = NULL;
510  }
511  if ((NULL != rp2c->p2c) && (NULL != rp2c->p2n))
512  {
514  rp2c->p2n = NULL;
515  }
516 }
struct NeighbourConnectNotification * ncn
Notification handle acquire to connect to a remote controller.
struct GNUNET_TESTBED_Controller * p2c
Controller of peer 2; If OCC_TYPE_REMOTE_LATERAL is the type of overlay connection then this can be N...
void GNUNET_TESTBED_forward_operation_msg_cancel_(struct OperationContext *opc)
Function to cancel an operation created by simply forwarding an operation message.
Definition: testbed_api.c:1406
struct Neighbour * p2n
The neighbour handle.
struct OperationContext * opc
Operation context for the suboperation we start to get the identity of the second peer...
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
occthe overlay connect context

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

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_free_non_null, 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, 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().

534 {
535  struct Peer *peer2;
536 
537  LOG_DEBUG ("0x%llx: Cleaning up occ\n",
538  occ->op_id);
539  GNUNET_free_non_null (occ->emsg);
541  if (NULL != occ->send_hello_task)
543  if (NULL != occ->cleanup_task)
545  if (NULL != occ->timeout_task)
547  if (NULL != occ->cgh_ch)
549  if (NULL != occ->ghh)
552  GNUNET_assert (NULL != GST_peer_list);
553  GNUNET_assert (occ->peer->reference_cnt > 0);
554  occ->peer->reference_cnt--;
555  if (PEER_EXPIRED (occ->peer))
556  GST_destroy_peer (occ->peer);
557  switch (occ->type)
558  {
559  case OCC_TYPE_LOCAL:
560  peer2 = GST_peer_list[occ->other_peer_id];
561  GNUNET_assert (peer2->reference_cnt > 0);
562  peer2->reference_cnt--;
563  if (PEER_EXPIRED (peer2))
564  GST_destroy_peer (peer2);
565  cleanup_occ_lp2c (&occ->p2ctx.local);
566  break;
567 
570  cleanup_occ_rp2c (&occ->p2ctx.remote);
571  break;
572  }
574  occq_tail,
575  occ);
576  GNUNET_free (occ);
577 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
uint64_t op_id
The id of the operation responsible for creating this context.
Type to be used when the first peer is local and the other peer is on a controller which is not start...
struct GST_ConnectionPool_GetHandle * cgh_ch
The GST_ConnectionPool_GetHandle for registering callback to notify CORE level peer connects and to g...
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct Peer ** GST_peer_list
A list of peers we know about.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
char * emsg
The error message we send if this overlay connect operation has timed out.
static struct OverlayConnectContext * occq_tail
DLL tail for OverlayConnectContext DLL.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Get GetHelloHandle to acquire a HELLO of the first peer.
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
uint32_t reference_cnt
References to peers are using in forwarded overlay contexts and remote overlay connect contexts...
This type is used if the overlay connection is local i.e.
static struct OverlayConnectContext * occq_head
DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2...
Type to be used when the first peer is local and the other peer is on a slave controller started by u...
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
void GST_destroy_peer(struct Peer *peer)
Function to destroy a peer.
#define PEER_EXPIRED(peer)
Condition for checking if given peer is ready to be destroyed.
struct GNUNET_SCHEDULER_Task * cleanup_task
The id of the cleanup task.
static void cleanup_occ_lp2c(struct LocalPeer2Context *lp2c)
Cleans up any used handles in local peer2 context.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
static void cleanup_occ_rp2c(struct RemotePeer2Context *rp2c)
Cleans up any used handles in remote peer2 context.
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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 cleaing up overlay connect context structure.

Parameters
clsthe overlay connect context

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

References cleanup_occ(), and OverlayConnectContext::cleanup_task.

Referenced by occ_cache_get_handle_core_cb(), and overlay_connect_notify().

587 {
588  struct OverlayConnectContext *occ = cls;
589 
590  occ->cleanup_task = NULL;
591  cleanup_occ (occ);
592 }
Context information for connecting 2 peers in overlay.
static void cleanup_occ(struct OverlayConnectContext *occ)
Cleanup overlay connect context structure.
struct GNUNET_SCHEDULER_Task * cleanup_task
The id of the cleanup task.
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
clsthe OverlayConnectContext

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

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().

602 {
603  struct OverlayConnectContext *occ = cls;
604 
605  GNUNET_assert (NULL != occ->timeout_task);
606  occ->timeout_task = NULL;
607  /* LOG (GNUNET_ERROR_TYPE_WARNING, */
608  /* "0x%llx: Timeout while connecting peers %u and %u: %s\n", occ->op_id, */
609  /* occ->peer->id, occ->other_peer_id, occ->emsg); */
611  occ->op_id,
612  occ->emsg);
613  cleanup_occ (occ);
614 }
uint64_t op_id
The id of the operation responsible for creating this context.
void GST_send_operation_fail_msg(struct GNUNET_SERVICE_Client *client, uint64_t operation_id, const char *emsg)
Send operation failure message to client.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
char * emsg
The error message we send if this overlay connect operation has timed out.
struct GNUNET_SERVICE_Client * client
The client which has requested for overlay connection.
static void cleanup_occ(struct OverlayConnectContext *occ)
Cleanup overlay connect context structure.
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
clientthe client that disconnected

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

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

Referenced by client_disconnect_cb().

624 {
625  struct ForwardedOperationContext *fopc;
626  struct ForwardedOperationContext *fopcn;
627  struct OverlayConnectContext *occ;
628  struct OverlayConnectContext *occn;
629 
630  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
631  {
632  fopcn = fopc->next;
633  if (fopc->client == client)
634  {
637  }
638  }
639  for (occ = occq_head; NULL != occ; occ = occn)
640  {
641  occn = occ->next;
642  if (occ->client == client)
643  cleanup_occ (occ);
644  }
645  // FIXME: implement clean up for client_keep replacements!
646 }
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
Context information for connecting 2 peers in overlay.
struct OverlayConnectContext * next
The next pointer for maintaining a DLL of all OverlayConnectContexts.
void GST_forwarded_operation_timeout(void *cls)
Task to free resources when forwarded operation has been timed out.
struct GNUNET_SERVICE_Client * client
The client which has requested for overlay connection.
struct ForwardedOperationContext * fopcq_head
DLL head for forwarded operation contexts.
static void cleanup_occ(struct OverlayConnectContext *occ)
Cleanup overlay connect context structure.
static struct OverlayConnectContext * occq_head
DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.
struct GNUNET_SERVICE_Client * client
The client to which we have to reply.
struct ForwardedOperationContext * next
The next pointer for DLL.
Context information for operations forwarded to subcontrollers.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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 653 of file gnunet-service-testbed_oc.c.

References OverlayConnectContext::client, env, GNUNET_TESTBED_ConnectionEventMessage::event_type, 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, GNUNET_TESTBED_ConnectionEventMessage::operation_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::peer, GNUNET_TESTBED_ConnectionEventMessage::peer1, and GNUNET_TESTBED_ConnectionEventMessage::peer2.

Referenced by occ_cache_get_handle_core_cb(), and overlay_connect_notify().

654 {
655  struct GNUNET_MQ_Envelope *env;
657 
658  LOG_DEBUG ("0x%llx: Peers connected - Sending overlay connect success\n",
659  occ->op_id);
660  env = GNUNET_MQ_msg (msg,
662  msg->event_type = htonl (GNUNET_TESTBED_ET_CONNECT);
663  msg->peer1 = htonl (occ->peer->id);
664  msg->peer2 = htonl (occ->other_peer_id);
665  msg->operation_id = GNUNET_htonll (occ->op_id);
667  env);
668 }
uint64_t op_id
The id of the operation responsible for creating this context.
Event notification from a controller to a client.
Definition: testbed.h:475
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT
Message for peer connect events.
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2437
uint32_t id
Our local reference id for this peer.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_SERVICE_Client * client
The client which has requested for overlay connection.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
uint32_t peer2
Second peer.
Definition: testbed.h:496
uint64_t operation_id
Operation ID that is used to identify this operation.
Definition: testbed.h:501
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
uint32_t peer1
First peer.
Definition: testbed.h:491
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
int32_t event_type
'enum GNUNET_TESTBED_EventType' (in NBO); either GNUNET_TESTBED_ET_CONNECT or GNUNET_TESTBED_ET_DISCO...
Definition: testbed.h:486
A connection between two peers was established.
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
#define LOG_DEBUG(...)
Debug logging shorthand.
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
clsclosure
new_peerthe peer that connected

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

References cleanup_occ_lp2c(), cleanup_occ_rp2c(), OverlayConnectContext::cleanup_task, do_cleanup_occ(), OverlayConnectContext::emsg, GNUNET_assert, GNUNET_free, GNUNET_free_non_null, GNUNET_i2s(), 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().

681 {
682  struct OverlayConnectContext *occ = cls;
683  char *new_peer_str;
684  char *other_peer_str;
685 
686  LOG_DEBUG ("Overlay connect notify\n");
687  if (0 ==
688  memcmp (new_peer, &occ->peer_identity,
689  sizeof(struct GNUNET_PeerIdentity)))
690  return;
691  new_peer_str = GNUNET_strdup (GNUNET_i2s (new_peer));
692  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
693  if (0 !=
694  memcmp (new_peer,
695  &occ->other_peer_identity,
696  sizeof(struct GNUNET_PeerIdentity)))
697  {
698  LOG_DEBUG ("Unexpected peer %s connected when expecting peer %s\n",
699  new_peer_str,
700  other_peer_str);
701  GNUNET_free (new_peer_str);
702  GNUNET_free (other_peer_str);
703  return;
704  }
705  GNUNET_free (new_peer_str);
706  LOG_DEBUG ("0x%llx: Peer %s connected to peer %s\n",
707  occ->op_id,
708  other_peer_str,
709  GNUNET_i2s (&occ->peer_identity));
710  GNUNET_free (other_peer_str);
711  if (NULL != occ->send_hello_task)
712  {
714  occ->send_hello_task = NULL;
715  }
716  GNUNET_assert (NULL != occ->timeout_task);
718  occ->timeout_task = NULL;
719  switch (occ->type)
720  {
721  case OCC_TYPE_LOCAL:
722  cleanup_occ_lp2c (&occ->p2ctx.local);
723  break;
724 
727  cleanup_occ_rp2c (&occ->p2ctx.remote);
728  break;
729  }
730  GNUNET_free_non_null (occ->emsg);
731  occ->emsg = NULL;
734  occ);
735 }
uint64_t op_id
The id of the operation responsible for creating this context.
Type to be used when the first peer is local and the other peer is on a controller which is not start...
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
char * emsg
The error message we send if this overlay connect operation has timed out.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
This type is used if the overlay connection is local i.e.
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2...
Type to be used when the first peer is local and the other peer is on a slave controller started by u...
static void send_overlay_connect_success_msg(struct OverlayConnectContext *occ)
FIXME.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
struct GNUNET_SCHEDULER_Task * cleanup_task
The id of the cleanup task.
static void cleanup_occ_lp2c(struct LocalPeer2Context *lp2c)
Cleans up any used handles in local peer2 context.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
static void cleanup_occ_rp2c(struct RemotePeer2Context *rp2c)
Cleans up any used handles in remote peer2 context.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void do_cleanup_occ(void *cls)
Task for cleaing up overlay connect context structure.
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsa struct OverlayConnectCtx *
chthe handle to CORE. Can be NULL if it is not requested
ththe handle to TRANSPORT. Can be NULL if it is not requested
acthe handle to ATS. Can be NULL if it is not requested
my_identitythe identity of our peer
cfgconfiguration of the peer

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

References ConnectivitySuggestContext::csh, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_ATS_connectivity_suggest(), GNUNET_free_non_null, 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().

755 {
756  struct OverlayConnectContext *occ = cls;
757  struct LocalPeer2Context *lp2c;
758 
760  GNUNET_assert (NULL != occ->timeout_task);
761  GNUNET_free_non_null (occ->emsg);
762  if (NULL == ac)
763  {
764  GNUNET_asprintf (&occ->emsg,
765  "0x%llx: Failed to connect to ATS of peer with id: %u",
766  occ->op_id,
767  occ->peer->id);
769  occ->timeout_task =
771  occ);
772  return;
773  }
774  occ->emsg = NULL;
775 
776  GNUNET_asprintf (&occ->emsg,
777  "0x%llx: Timeout during GNUNET_ATS_connectivity_suggest() at peer %s",
778  occ->op_id,
780 
781  lp2c = &occ->p2ctx.local;
782  lp2c->tcc.csh =
784  &occ->peer_identity,
785  1);
786 }
uint64_t op_id
The id of the operation responsible for creating this context.
Context data for operations on second peer in local overlay connection contexts.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t id
Our local reference id for this peer.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
char * emsg
The error message we send if this overlay connect operation has timed out.
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
struct GNUNET_ATS_ConnectivitySuggestHandle * GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
We would like to receive address suggestions for a peer.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
This type is used if the overlay connection is local i.e.
struct GNUNET_ATS_ConnectivitySuggestHandle * csh
The ATS handle for the connectivity suggestion.
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
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
clsa struct RemoteOverlayConnectCtx *
chthe handle to CORE. Can be NULL if it is not requested
ththe handle to TRANSPORT. Can be NULL if it is not requested
acthe handle to ATS. Can be NULL if it is not requested
my_identitythe identity of our peer

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

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

Referenced by rocc_hello_sent_cb().

805 {
806  struct RemoteOverlayConnectCtx *rocc = cls;
807 
808  rocc->tcc.csh =
810  &rocc->a_id,
811  1);
812 }
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
struct ConnectivitySuggestContext tcc
The transport try connect context.
struct GNUNET_ATS_ConnectivitySuggestHandle * GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
We would like to receive address suggestions for a peer.
Context information for remote overlay connect operations.
struct GNUNET_ATS_ConnectivitySuggestHandle * csh
The ATS handle for the connectivity suggestion.
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
clsthe 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
clsthe OverlayConnectContext

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

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 occ_cache_get_handle_ats_rocc_cb(), p2_transport_connect(), and p2_transport_connect_cache_callback().

913 {
914  struct OverlayConnectContext *occ = cls;
915  struct LocalPeer2Context *lp2c;
916  char *other_peer_str;
917 
918  occ->send_hello_task = NULL;
919  GNUNET_assert (NULL != occ->timeout_task);
920  GNUNET_assert (NULL != occ->hello);
921  if (OCC_TYPE_LOCAL != occ->type)
922  {
923  send_hello_thru_rocc (occ);
924  return;
925  }
926  lp2c = &occ->p2ctx.local;
927  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
928  LOG_DEBUG ("0x%llx: Offering HELLO of %s to %s\n",
929  occ->op_id,
930  GNUNET_i2s (&occ->peer_identity),
931  other_peer_str);
932  GNUNET_free (other_peer_str);
933  lp2c->ohh =
935  occ->hello,
937  occ);
938  if (NULL == lp2c->ohh)
939  {
940  GNUNET_break (0);
941  occ->send_hello_task =
944  100
947  &send_hello, occ);
948  }
949 }
uint64_t op_id
The id of the operation responsible for creating this context.
static void send_hello_thru_rocc(struct OverlayConnectContext *occ)
Sends the HELLO of peer1 to peer2's controller through remote overlay connect request.
Context data for operations on second peer in local overlay connection contexts.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering the HELLO of the first peer to the second peer.
Context information for connecting 2 peers in overlay.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
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...
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration of the peer from cache.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
This type is used if the overlay connection is local i.e.
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2...
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
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 sendin...
struct GNUNET_TRANSPORT_OfferHelloHandle * GNUNET_TRANSPORT_offer_hello(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_MessageHeader *hello, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Offer the transport service the HELLO of another peer.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG_DEBUG(...)
Debug logging shorthand.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_free(ptr)
Wrapper around free.
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
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
clsthe overlay connect context

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

References ConnectivitySuggestContext::cgh_p2_ats, Peer::details, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_free_non_null, 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().

834 {
835  struct OverlayConnectContext *occ = cls;
836  struct LocalPeer2Context *lp2c;
837  struct Peer *peer2;
838 
840  GNUNET_assert (NULL != occ->timeout_task);
841  lp2c = &occ->p2ctx.local;
842  lp2c->ohh = NULL;
843 
844  GNUNET_assert (NULL == occ->send_hello_task);
845  GNUNET_free_non_null (occ->emsg);
846 
847  GNUNET_asprintf (&occ->emsg,
848  "0x%llx: Timeout while acquiring ATS of %s from cache",
849  occ->op_id,
851  GNUNET_assert (NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
852  lp2c->tcc.cgh_p2_ats =
854  peer2->details.local.cfg,
857  occ, NULL, NULL, NULL);
858 }
uint64_t op_id
The id of the operation responsible for creating this context.
Context data for operations on second peer in local overlay connection contexts.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering the HELLO of the first peer to the second peer.
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.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct Peer ** GST_peer_list
A list of peers we know about.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
char * emsg
The error message we send if this overlay connect operation has timed out.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
union Peer::@66 details
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
This type is used if the overlay connection is local i.e.
struct Peer::@66::@67 local
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2...
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GST_ConnectionPool_GetHandle * cgh_p2_ats
The GetCacheHandle for the peer2's ATS handle.
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
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
occthe 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.

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, and OverlayConnectContext::type.

Referenced by send_hello().

870 {
872  char *other_peer_str;
873  uint16_t msize;
874  uint16_t hello_size;
875 
877  GNUNET_assert (NULL != occ->hello);
878  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
879  LOG_DEBUG (
880  "0x%llx: Offering HELLO of %s (size: %u) to %s via Remote Overlay Request\n",
881  occ->op_id,
882  GNUNET_i2s (&occ->peer_identity),
883  ntohs (occ->hello->size),
884  other_peer_str);
885  GNUNET_free (other_peer_str);
886  hello_size = ntohs (occ->hello->size);
887  msize = sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage)
888  + hello_size;
889  msg = GNUNET_malloc (msize);
890  msg->header.type =
892  msg->header.size = htons (msize);
893  msg->peer = htonl (occ->other_peer_id);
894  msg->operation_id = GNUNET_htonll (occ->op_id);
895  msg->peer_identity = occ->peer_identity;
896  GNUNET_memcpy (msg->hello,
897  occ->hello,
898  hello_size);
900  &msg->header);
901 }
uint64_t op_id
The id of the operation responsible for creating this context.
Message sent from host controller of a peer(A) to the host controller of another peer(B) to request B...
Definition: testbed.h:408
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_TESTBED_Controller * p2c
Controller of peer 2; If OCC_TYPE_REMOTE_LATERAL is the type of overlay connection then this can be N...
#define GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT
Message to request a controller to make one of its peer to connect to another peer using the containe...
enum OverlayConnectContextType type
The type of this context information.
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
This type is used if the overlay connection is local i.e.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
void GNUNET_TESTBED_queue_message_(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_MessageHeader *msg)
Queues a message in send queue for sending to the service.
Definition: testbed_api.c:1335
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe closure passed to GST_cache_get_handle_transport()
chthe handle to CORE. Can be NULL if it is not requested
ththe handle to TRANSPORT. Can be NULL if it is not requested
acthe handle to ATS. Can be NULL if it is not requested
ignore_peer identity which is ignored in this callback
cfgconfiguration of the peer

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

References 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().

970 {
971  struct OverlayConnectContext *occ = cls;
972 
974  if (NULL == th)
975  {
976  GNUNET_asprintf (&occ->emsg,
977  "0x%llx: Cannot connect to TRANSPORT of %s",
978  occ->op_id,
981  occ->timeout_task =
983  return;
984  }
985  occ->p2ctx.local.tcc.th_ = th;
986  occ->p2ctx.local.tcc.cfg = cfg;
987  GNUNET_asprintf (&occ->emsg,
988  "0x%llx: Timeout while offering HELLO to %s",
989  occ->op_id,
992 }
uint64_t op_id
The id of the operation responsible for creating this context.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
char * emsg
The error message we send if this overlay connect operation has timed out.
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
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...
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration of the peer from cache.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
This type is used if the overlay connection is local i.e.
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2...
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
struct GNUNET_TRANSPORT_CoreHandle * th_
The transport handle obtained from cache.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
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
occthe overlay connect context

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

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().

1003 {
1004  struct Peer *peer2;
1005 
1006  /* HUH? Why to *obtain* HELLO? Seems we use this to *SEND* the
1007  HELLO! */
1009  "Connecting to transport of peer %s to obtain HELLO\n",
1011  GNUNET_assert (NULL == occ->emsg);
1012  GNUNET_assert (NULL != occ->hello);
1013  GNUNET_assert (NULL == occ->ghh);
1014  GNUNET_assert (NULL == occ->p1th_);
1015  GNUNET_assert (NULL == occ->cgh_p1th);
1016  if (OCC_TYPE_LOCAL == occ->type)
1017  {
1018  GNUNET_assert (NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
1019  occ->p2ctx.local.tcc.cgh_p2_th =
1021  peer2->details.local.cfg,
1024  occ, NULL, NULL, NULL);
1025  return;
1026  }
1027  GNUNET_asprintf (&occ->emsg,
1028  "0x%llx: Timeout while offering HELLO to %s",
1029  occ->op_id,
1032 }
uint64_t op_id
The id of the operation responsible for creating this context.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct Peer ** GST_peer_list
A list of peers we know about.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
char * emsg
The error message we send if this overlay connect operation has timed out.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_TRANSPORT_CoreHandle * p1th_
Transport handle of the first peer obtained from cache to get its HELLO.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Get GetHelloHandle to acquire a HELLO of the first peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
enum OverlayConnectContextType type
The type of this context information.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
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...
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
union Peer::@66 details
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
This type is used if the overlay connection is local i.e.
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.
struct Peer::@66::@67 local
struct GNUNET_SCHEDULER_Task * send_hello_task
The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to connect to peer 2...
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
#define GNUNET_log(kind,...)
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
struct GST_ConnectionPool_GetHandle * cgh_p2_th
The GetCacheHandle for the peer2's transport handle (used to offer the HELLO to the peer)...
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
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
clsempty flag to set
addressthe HELLO
expirationexpiration of the HELLO
Returns
GNUNET_OK

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

References GNUNET_NO, and GNUNET_OK.

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

1047 {
1048  int *empty = cls;
1049 
1050  *empty = GNUNET_NO;
1051  return GNUNET_OK;
1052 }
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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
clsclosure
helloour updated HELLO

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

References OverlayConnectContext::cgh_p1th, OverlayConnectContext::emsg, OverlayConnectContext::ghh, GNUNET_free_non_null, 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().

1066 {
1067  struct OverlayConnectContext *occ = cls;
1068  int empty;
1069  uint16_t msize;
1070 
1071  msize = ntohs (hello->size);
1072  empty = GNUNET_YES;
1073  (void) GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *)
1074  hello, GNUNET_NO,
1075  &test_address,
1076  &empty);
1077  if (GNUNET_YES == empty)
1078  {
1079  LOG_DEBUG ("0x%llx: HELLO of %s is empty\n",
1080  occ->op_id,
1081  GNUNET_i2s (&occ->peer_identity));
1082  return;
1083  }
1084  LOG_DEBUG ("0x%llx: Received HELLO of %s\n",
1085  occ->op_id,
1086  GNUNET_i2s (&occ->peer_identity));
1087  occ->hello = GNUNET_malloc (msize);
1088  GST_cache_add_hello (occ->peer->id, hello);
1089  GNUNET_memcpy (occ->hello, hello, msize);
1091  occ->ghh = NULL;
1093  occ->cgh_p1th = NULL;
1094  occ->p1th_ = NULL;
1095  GNUNET_free_non_null (occ->emsg);
1096  occ->emsg = NULL;
1097  p2_transport_connect (occ);
1098 }
uint64_t op_id
The id of the operation responsible for creating this context.
A HELLO message is used to exchange information about transports with other peers.
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...
Context information for connecting 2 peers in overlay.
uint32_t id
Our local reference id for this peer.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
char * emsg
The error message we send if this overlay connect operation has timed out.
struct GNUNET_TRANSPORT_CoreHandle * p1th_
Transport handle of the first peer obtained from cache to get its HELLO.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
struct GNUNET_HELLO_Message * GNUNET_HELLO_iterate_addresses(const struct GNUNET_HELLO_Message *msg, int return_modified, GNUNET_HELLO_AddressIterator it, void *it_cls)
Iterate over all of the addresses in the HELLO.
Definition: hello.c:254
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Get GetHelloHandle to acquire a HELLO of the first peer.
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_malloc(size)
Wrapper around malloc.
void GST_cache_add_hello(const unsigned int peer_id, const struct GNUNET_MessageHeader *hello)
Caches the HELLO of the given peer.
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
clsthe closure passed to GST_cache_get_handle_transport()
chthe handle to CORE. Can be NULL if it is not requested
ththe handle to TRANSPORT. Can be NULL if it is not requested
acthe 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.

References OverlayConnectContext::cgh_p1th, OverlayConnectContext::emsg, OverlayConnectContext::ghh, GNUNET_asprintf(), GNUNET_assert, GNUNET_free_non_null, 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().

1118 {
1119  struct OverlayConnectContext *occ = cls;
1120 
1121  GNUNET_free_non_null (occ->emsg);
1122  occ->emsg = NULL;
1123  if (NULL == th)
1124  {
1125  GNUNET_asprintf (&occ->emsg,
1126  "0x%llx: Cannot connect to TRANSPORT of %s",
1127  occ->op_id,
1128  GNUNET_i2s (&occ->peer_identity));
1130  occ->timeout_task =
1132  return;
1133  }
1134  GNUNET_assert (NULL == occ->p1th_);
1135  GNUNET_assert (NULL != occ->cgh_p1th);
1136  occ->p1th_ = th;
1137  GNUNET_asprintf (&occ->emsg,
1138  "0x%llx: Timeout while acquiring HELLO of peer %s",
1139  occ->op_id,
1140  GNUNET_i2s (&occ->peer_identity));
1141  occ->ghh = GNUNET_TRANSPORT_hello_get (cfg,
1143  &hello_update_cb,
1144  occ);
1145 }
uint64_t op_id
The id of the operation responsible for creating this context.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
char * emsg
The error message we send if this overlay connect operation has timed out.
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_TRANSPORT_CoreHandle * p1th_
Transport handle of the first peer obtained from cache to get its HELLO.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Get GetHelloHandle to acquire a HELLO of the first peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
struct GNUNET_TRANSPORT_HelloGetHandle * GNUNET_TRANSPORT_hello_get(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_TRANSPORT_AddressClass ac, GNUNET_TRANSPORT_HelloUpdateCallback rec, void *rec_cls)
Obtain updates on changes to the HELLO message for this peer.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsthe closure passed to GST_cache_get_handle_transport()
chthe handle to CORE. Can be NULL if it is not requested
ththe handle to TRANSPORT. Can be NULL if it is not requested
acthe handle to ATS. Can be NULL if it is not requested
my_identitythe identity of our peer

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

References OverlayConnectContext::cgh_p1th, OverlayConnectContext::cleanup_task, Peer::details, do_cleanup_occ(), OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_copy_message(), GNUNET_CORE_get_mq(), GNUNET_free_non_null, 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().

1164 {
1165  struct OverlayConnectContext *occ = cls;
1166  const struct GNUNET_MessageHeader *hello;
1167 
1168  GNUNET_assert (NULL != occ->timeout_task);
1169  GNUNET_free_non_null (occ->emsg);
1170  if ((NULL == ch) || (NULL == my_identity))
1171  {
1172  GNUNET_asprintf (&occ->emsg,
1173  "0x%llx: Failed to connect to CORE of peer with "
1174  "id: %u",
1175  occ->op_id,
1176  occ->peer->id);
1178  occ->timeout_task =
1180  return;
1181  }
1182  occ->emsg = NULL;
1183  if (NULL !=
1184  GNUNET_CORE_get_mq (ch,
1185  &occ->other_peer_identity))
1186  {
1187  LOG_DEBUG ("0x%llx: Target peer already connected\n",
1188  occ->op_id);
1190  occ->timeout_task = NULL;
1193  return;
1194  }
1195  occ->peer_identity = *my_identity;
1196  LOG_DEBUG ("0x%llx: Acquiring HELLO of peer %s\n",
1197  occ->op_id,
1198  GNUNET_i2s (&occ->peer_identity));
1199  /* Lookup for HELLO in hello cache */
1200  if (NULL != (hello = GST_cache_lookup_hello (occ->peer->id)))
1201  {
1202  LOG_DEBUG ("0x%llx: HELLO of peer %s found in cache\n",
1203  occ->op_id,
1204  GNUNET_i2s (&occ->peer_identity));
1205  occ->hello = GNUNET_copy_message (hello);
1206  p2_transport_connect (occ);
1207  return;
1208  }
1209  GNUNET_asprintf (&occ->emsg,
1210  "0x%llx: Timeout while acquiring TRANSPORT of %s from cache",
1211  occ->op_id,
1212  GNUNET_i2s (&occ->peer_identity));
1213  occ->cgh_p1th =
1215  occ->peer->details.local.cfg,
1218  occ,
1219  NULL, NULL, NULL);
1220 }
uint64_t op_id
The id of the operation responsible for creating this context.
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...
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t id
Our local reference id for this peer.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_PeerIdentity my_identity
Identity of this peer.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
char * emsg
The error message we send if this overlay connect operation has timed out.
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
union Peer::@66 details
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
const struct GNUNET_MessageHeader * GST_cache_lookup_hello(const unsigned int peer_id)
Looks up in the hello cache and returns the HELLO of the given peer.
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.
struct Peer::@66::@67 local
static void send_overlay_connect_success_msg(struct OverlayConnectContext *occ)
FIXME.
struct GNUNET_MQ_Handle * GNUNET_CORE_get_mq(const struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *pid)
Obtain the message queue for a connected peer.
Definition: core_api.c:761
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
struct GNUNET_SCHEDULER_Task * cleanup_task
The id of the cleanup task.
Header for all communications.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void do_cleanup_occ(void *cls)
Task for cleaing up overlay connect context structure.
#define LOG_DEBUG(...)
Debug logging shorthand.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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 successfull.

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

Parameters
clsForwardedOperationContext
msgthe peer create success message

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

References OverlayConnectContext::cgh_ch, Peer::details, OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_free_non_null, 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, 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, OverlayConnectContext::type, and GNUNET_MessageHeader::type.

Referenced by p2_controller_connect_cb().

1234 {
1235  struct OverlayConnectContext *occ = cls;
1236  struct RemotePeer2Context *rp2c;
1238 
1239  GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1240  rp2c = &occ->p2ctx.remote;
1241  rp2c->opc = NULL;
1242  GNUNET_assert (NULL != occ->timeout_task);
1244  {
1246  occ->timeout_task =
1248  }
1249  cmsg =
1251  occ->other_peer_identity = cmsg->peer_identity;
1252  GNUNET_free_non_null (occ->emsg);
1253  GNUNET_asprintf (&occ->emsg,
1254  "0x%llx: Timeout while connecting to CORE of peer with "
1255  "id: %u",
1256  occ->op_id,
1257  occ->peer->id);
1258  occ->cgh_ch =
1260  occ->peer->details.local.cfg,
1263  occ,
1264  &occ->other_peer_identity,
1266  occ);
1267  return;
1268 }
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.
uint64_t op_id
The id of the operation responsible for creating this context.
struct GST_ConnectionPool_GetHandle * cgh_ch
The GST_ConnectionPool_GetHandle for registering callback to notify CORE level peer connects and to g...
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t id
Our local reference id for this peer.
Peer configuration and identity reply from controller to a client.
Definition: testbed.h:603
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Context data for operations on second peer in remote overlay connection contexts. ...
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
char * emsg
The error message we send if this overlay connect operation has timed out.
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
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.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
enum OverlayConnectContextType type
The type of this context information.
union Peer::@66 details
#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION
Message containing the peer's information.
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
struct GNUNET_PeerIdentity peer_identity
Identity of the peer.
Definition: testbed.h:623
This type is used if the overlay connection is local i.e.
struct Peer::@66::@67 local
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
struct OperationContext * opc
Operation context for the suboperation we start to get the identity of the second peer...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsthe RegisteredHostContext
emsgthe error message; NULL if host registration is successful

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

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

Referenced by register_host().

1279 {
1280  struct RegisteredHostContext *rhc = cls;
1281 
1282  rhc->state = RHC_DONE;
1283  GST_process_next_focc (rhc);
1284 }
This context information will be created for each host that is registered at slave controllers during...
enum RegisteredHostContext::RHCState state
void GST_process_next_focc(struct RegisteredHostContext *rhc)
Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext.
State where we attempt to do the overlay connection again.
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
clspointer 2 pointer of RegisteredHostContext
keycurrent key code
valuevalue in the hash map
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

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

Referenced by register_host().

1301 {
1302  struct RegisteredHostContext **rh = cls;
1303  struct RegisteredHostContext *rh_val = value;
1304 
1305  if ((rh_val->host == (*rh)->host) && (rh_val->reg_host == (*rh)->reg_host))
1306  {
1307  GNUNET_free (*rh);
1308  *rh = rh_val;
1309  return GNUNET_NO;
1310  }
1311  return GNUNET_YES;
1312 }
This context information will be created for each host that is registered at slave controllers during...
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_TESTBED_Host * host
The host of the controller which has to connect to the above rhost.
static char * value
Value of the record to add/remove.
struct GNUNET_TESTBED_Host * reg_host
The host which is being registered.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
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_hostthe host which is being registered in RegisteredHostContext
hostthe host of the controller which has to connect to the above rhost
Returns
the hashcode

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

References GNUNET_CRYPTO_hash(), and GNUNET_TESTBED_host_get_id_().

Referenced by register_host().

1325 {
1326  struct GNUNET_HashCode hash;
1327  uint32_t host_ids[2];
1328 
1329  host_ids[0] = GNUNET_TESTBED_host_get_id_ (reg_host);
1330  host_ids[1] = GNUNET_TESTBED_host_get_id_ (host);
1331  GNUNET_CRYPTO_hash (host_ids, sizeof(host_ids), &hash);
1332  return hash;
1333 }
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain the host's unique global ID.
A 512-bit hashcode.
Here is the call graph for this function:
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
slavethe slave where registration has to be checked. The check is actually done through a locally maintained hashmap. No communication with the slave is involved.
hostthe 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 1350 of file gnunet-service-testbed_oc.c.

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().

1352 {
1353  struct GNUNET_HashCode hash;
1354  struct RegisteredHostContext *rhc;
1355 
1356  rhc = GNUNET_new (struct RegisteredHostContext);
1357  rhc->reg_host = host;
1358  rhc->host = GST_host_list[slave->host_id];
1359  GNUNET_assert (NULL != rhc->reg_host);
1360  GNUNET_assert (NULL != rhc->host);
1361  rhc->state = RHC_INIT;
1362  hash = hash_hosts (rhc->reg_host, rhc->host);
1363  if ((GNUNET_NO ==
1365  &hash)) ||
1366  (GNUNET_SYSERR !=
1368  &hash,
1370  &rhc)))
1371  {
1372  /* create and add a new registerd host context */
1373  /* add the focc to its queue */
1375  &hash,
1376  rhc,
1380  rhc,
1381  rhc->reg_host);
1382  }
1383  else
1384  {
1385  /* rhc is now set to the existing one from the hash map by
1386  * reghost_match_iterator() */
1387  /* if queue is empty then ignore creating focc and proceed with normal
1388  * forwarding */
1389  if (RHC_DONE == rhc->state)
1390  return NULL;
1391  }
1392  return rhc;
1393 }
struct GNUNET_CONTAINER_MultiHashMap * reghost_map
Hashmap to hold Registered host contexts.
This context information will be created for each host that is registered at slave controllers during...
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.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GST_queue_host_registration(struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
Adds a host registration's request to a slave's registration queue.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
int GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL)...
struct GNUNET_TESTBED_Host * host
The host of the controller which has to connect to the above rhost.
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
A 512-bit hashcode.
enum RegisteredHostContext::RHCState state
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_TESTBED_Host * reg_host
The host which is being registered.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static int reghost_match_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to match a registered host context.
Allow multiple values with the same key.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
uint32_t host_id
The id of the host this controller is running on.
State where we attempt to do the overlay connection again.
static void host_registration_comp(void *cls, const char *emsg)
Callback which will be called after a host registration succeeded or failed.
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
msgthe overlay connect request message to be forwarded
clientthe client to which the status of the forwarded request has to be notified

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

References ForwardedOperationContext::client, ForwardedOverlayConnectContext::client, Route::dest, Peer::details, 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, GNUNET_TESTBED_OverlayConnectMessage::header, Peer::is_remote, LOG_DEBUG, OP_OVERLAY_CONNECT, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, ForwardedOverlayConnectContext::operation_id, GNUNET_TESTBED_OverlayConnectMessage::operation_id, ForwardedOverlayConnectContext::orig_msg, peer, ForwardedOverlayConnectContext::peer1, GNUNET_TESTBED_OverlayConnectMessage::peer1, ForwardedOverlayConnectContext::peer2, GNUNET_TESTBED_OverlayConnectMessage::peer2, ForwardedOverlayConnectContext::peer2_host_id, GNUNET_TESTBED_OverlayConnectMessage::peer2_host_id, register_host(), Peer::remote, ForwardedOverlayConnectContext::rhc, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, VALID_HOST_ID, and VALID_PEER_ID.

Referenced by handle_overlay_connect().

1408 {
1409  struct ForwardedOperationContext *fopc;
1410  struct Route *route_to_peer2_host;
1411  struct Route *route_to_peer1_host;
1412  struct Peer *peer;
1413  struct RegisteredHostContext *rhc;
1414  struct ForwardedOverlayConnectContext *focc;
1415  uint64_t op_id;
1416  uint32_t peer2_host_id;
1417  uint32_t p1;
1418  uint32_t p2;
1419 
1420  p1 = ntohl (msg->peer1);
1421  p2 = ntohl (msg->peer2);
1422  op_id = GNUNET_ntohll (msg->operation_id);
1423  peer2_host_id = ntohl (msg->peer2_host_id);
1425  GNUNET_assert (VALID_HOST_ID (peer2_host_id));
1426  peer = GST_peer_list[p1];
1427  GNUNET_assert (GNUNET_YES == peer->is_remote);
1428  LOG_DEBUG ("0x%llx: Forwarding overlay connect\n", op_id);
1429  route_to_peer2_host = GST_find_dest_route (peer2_host_id);
1430  route_to_peer1_host = GST_find_dest_route
1431  (peer->details.remote.remote_host_id);
1432  GNUNET_assert (NULL != route_to_peer1_host);
1433  if ((NULL != route_to_peer2_host) &&
1434  (route_to_peer1_host->dest == route_to_peer2_host->dest))
1435  goto forward;
1436  /* Peer2 is either with us OR peer1 and peer2 can be reached through
1437  different subtrees OR peer2 is on a subtree unknown to us */
1438  if (NULL != (rhc = register_host (peer->details.remote.slave,
1439  GST_host_list[peer2_host_id])))
1440  {
1441  LOG_DEBUG ("Queueing forwarding FOCC for connecting peers %u and %u\n", p1,
1442  p2);
1444  focc->rhc = rhc;
1445  focc->peer1 = p1;
1446  focc->peer2 = p2;
1447  focc->peer2_host_id = peer2_host_id;
1448  focc->orig_msg = GNUNET_copy_message (&msg->header);
1449  focc->operation_id = op_id;
1450  focc->client = client;
1452  rhc->focc_dll_tail,
1453  focc);
1454  return;
1455  }
1456 
1457 forward:
1458  LOG_DEBUG ("Forwarding without FOCC for connecting peers %u and %u\n", p1,
1459  p2);
1460  fopc = GNUNET_new (struct ForwardedOperationContext);
1461  fopc->client = client;
1462  fopc->operation_id = op_id;
1463  fopc->type = OP_OVERLAY_CONNECT;
1464  fopc->opc =
1466  slave->controller, op_id,
1467  &msg->header,
1469  fopc);
1470  fopc->timeout_task =
1473  fopc);
1475  fopcq_tail,
1476  fopc);
1477 }
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
struct ForwardedOverlayConnectContext * focc_dll_head
Head of the ForwardedOverlayConnectContext DLL.
This context information will be created for each host that is registered at slave controllers during...
int is_remote
Is this peer locally created?
struct GNUNET_MessageHeader * orig_msg
A copy of the original overlay connect message.
struct GNUNET_SERVICE_Client * client
The client handle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define VALID_PEER_ID(id)
Condition to check if peer id is valid.
struct OperationContext * opc
The generated operation context.
struct ForwardedOverlayConnectContext * focc_dll_tail
Tail of the ForwardedOverlayConnectContext DLL.
struct Peer ** GST_peer_list
A list of peers we know about.
uint64_t operation_id
Operation ID that is used to identify this operation.
Definition: testbed.h:390
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct Peer::@66::@68 remote
void GST_forwarded_operation_reply_relay(void *cls, const struct GNUNET_MessageHeader *msg)
Callback to relay the reply msg of a forwarded operation back to the client.
void GST_forwarded_operation_timeout(void *cls)
Task to free resources when forwarded operation has been timed out.
uint32_t peer2
The id of peer 2.
uint32_t peer2
Unique ID for the second peer.
Definition: testbed.h:395
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
struct ForwardedOperationContext * fopcq_head
DLL head for forwarded operation contexts.
uint64_t operation_id
The id of the operation which created this context information.
uint32_t peer1
Unique ID for the first peer.
Definition: testbed.h:385
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
enum OperationType type
The type of the operation which is forwarded.
Context information to used during operations which forward the overlay connect message.
uint32_t peer2_host_id
The ID of the host which runs peer2.
Definition: testbed.h:400
A routing entry.
union Peer::@66 details
static int forward
Search direction: forward.
Definition: gnunet-abd.c:162
struct Route * GST_find_dest_route(uint32_t host_id)
Finds the route with directly connected host as destination through which the destination host can be...
static struct RegisteredHostContext * register_host(struct Slave *slave, struct GNUNET_TESTBED_Host *host)
Checks if the given host is registered at the given slave.
uint32_t peer2_host_id
Id of the host where peer2 is running.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Overlay connection operation.
Definition: testbed_api.h:79
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct OperationContext * GNUNET_TESTBED_forward_operation_msg_(struct GNUNET_TESTBED_Controller *controller, uint64_t operation_id, const struct GNUNET_MessageHeader *msg, GNUNET_MQ_MessageCallback cc, void *cc_cls)
Sends the given message as an operation.
Definition: testbed_api.c:1369
#define VALID_HOST_ID(id)
Condition to check if host id is valid.
struct ForwardedOperationContext * fopcq_tail
DLL tail for forwarded operation contexts.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT.
Definition: testbed.h:380
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
struct GNUNET_SERVICE_Client * client
The client to which we have to reply.
struct RegisteredHostContext * rhc
Which host does this FOCC belong to?
uint64_t operation_id
The id of the operation that has been forwarded.
#define GNUNET_YES
Definition: gnunet_common.h:77
Context information for operations forwarded to subcontrollers.
uint32_t dest
destination host
#define LOG_DEBUG(...)
Debug logging shorthand.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
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
clsthe overlay connect contexts
chandle to the controller connection

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

References OverlayConnectContext::emsg, GNUNET_asprintf(), GNUNET_assert, GNUNET_free_non_null, 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, OverlayConnectContext::type, and GNUNET_MessageHeader::type.

Referenced by handle_overlay_connect().

1490 {
1491  struct OverlayConnectContext *occ = cls;
1492  struct RemotePeer2Context *rp2c;
1494 
1495  GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1496  rp2c = &occ->p2ctx.remote;
1497  rp2c->ncn = NULL;
1498  rp2c->p2c = c;
1499  cmsg.header.size =
1500  htons (sizeof(struct GNUNET_TESTBED_PeerGetConfigurationMessage));
1501  cmsg.header.type =
1503  cmsg.peer_id = htonl (occ->other_peer_id);
1504  cmsg.operation_id = GNUNET_htonll (occ->op_id);
1505  rp2c->opc =
1507  occ->op_id,
1508  &cmsg.header,
1510  occ);
1511  GNUNET_free_non_null (occ->emsg);
1512  GNUNET_asprintf (&occ->emsg,
1513  "0x%llx: Timeout while getting peer identity of peer "
1514  "with id: %u",
1515  occ->op_id,
1516  occ->other_peer_id);
1517 }
uint64_t op_id
The id of the operation responsible for creating this context.
struct NeighbourConnectNotification * ncn
Notification handle acquire to connect to a remote controller.
Message sent from client to testing service to obtain the configuration of a peer.
Definition: testbed.h:581
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Context data for operations on second peer in remote overlay connection contexts. ...
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
char * emsg
The error message we send if this overlay connect operation has timed out.
struct GNUNET_TESTBED_Controller * p2c
Controller of peer 2; If OCC_TYPE_REMOTE_LATERAL is the type of overlay connection then this can be N...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
enum OverlayConnectContextType type
The type of this context information.
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 successf...
This type is used if the overlay connection is local i.e.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
#define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION
Message to get a peer's information.
struct OperationContext * GNUNET_TESTBED_forward_operation_msg_(struct GNUNET_TESTBED_Controller *controller, uint64_t operation_id, const struct GNUNET_MessageHeader *msg, GNUNET_MQ_MessageCallback cc, void *cc_cls)
Sends the given message as an operation.
Definition: testbed_api.c:1369
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
struct OperationContext * opc
Operation context for the suboperation we start to get the identity of the second peer...
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
clsidentification of the client
msgthe actual message

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

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_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::is_remote, Peer::local, LOG, LOG_DEBUG, RemotePeer2Context::ncn, occ_cache_get_handle_core_cb(), OCC_TYPE_LOCAL, OCC_TYPE_REMOTE_LATERAL, OCC_TYPE_REMOTE_SLAVE, OverlayConnectContext::op_id, GNUNET_TESTBED_OverlayConnectMessage::operation_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::other_peer_identity, overlay_connect_notify(), p2_controller_connect_cb(), RemotePeer2Context::p2c, OverlayConnectContext::p2ctx, RemotePeer2Context::p2n, peer, OverlayConnectContext::peer, GNUNET_TESTBED_OverlayConnectMessage::peer1, GNUNET_TESTBED_OverlayConnectMessage::peer2, GNUNET_TESTBED_OverlayConnectMessage::peer2_host_id, Peer::reference_cnt, Peer::remote, OverlayConnectContext::remote, timeout_overlay_connect(), OverlayConnectContext::timeout_task, OverlayConnectContext::type, VALID_HOST_ID, and VALID_PEER_ID.

1529 {
1530  struct GNUNET_SERVICE_Client *client = cls;
1531  struct Peer *peer;
1532  struct Peer *peer2;
1533  struct OverlayConnectContext *occ;
1534  struct Neighbour *p2n;
1535  uint64_t operation_id;
1536  uint32_t p1;
1537  uint32_t p2;
1538  uint32_t peer2_host_id;
1539 
1540  p1 = ntohl (msg->peer1);
1541  p2 = ntohl (msg->peer2);
1542  if (! VALID_PEER_ID (p1))
1543  {
1544  GNUNET_break (0);
1545  GNUNET_SERVICE_client_drop (client);
1546  return;
1547  }
1548  peer = GST_peer_list[p1];
1549  operation_id = GNUNET_ntohll (msg->operation_id);
1550  LOG_DEBUG
1551  ("Received overlay connect for peers %u and %u with op id: 0x%llx\n",
1552  p1,
1553  p2,
1554  operation_id);
1555  peer2_host_id = ntohl (msg->peer2_host_id);
1556  if (GNUNET_YES == peer->is_remote)
1557  {
1558  if (! VALID_HOST_ID (peer2_host_id))
1559  {
1560  GNUNET_break (0);
1561  GNUNET_SERVICE_client_drop (client);
1562  return;
1563  }
1564  forward_overlay_connect (msg, client);
1566  return;
1567  }
1568  p2n = NULL;
1569  occ = GNUNET_new (struct OverlayConnectContext);
1570  occ->type = OCC_TYPE_LOCAL;
1571  if (! VALID_PEER_ID (p2)) /* May be peer2 is on a another controller */
1572  {
1573  if (NULL == (p2n = GST_get_neighbour (peer2_host_id)))
1574  {
1575  if (! VALID_HOST_ID (peer2_host_id))
1576  {
1577  GNUNET_break (0);
1579  "0x%llx: Peer %u's host not in our neighbours list\n",
1580  operation_id, p2);
1581  GNUNET_SERVICE_client_drop (client);
1582  GNUNET_free (occ);
1583  return;
1584  }
1585  p2n = GST_create_neighbour (GST_host_list[peer2_host_id]);
1586  }
1588  occ->p2ctx.remote.p2n = p2n;
1589  }
1590  else if (GNUNET_YES == GST_peer_list[p2]->is_remote)
1591  {
1592  occ->type = OCC_TYPE_REMOTE_SLAVE;
1593  occ->p2ctx.remote.p2c = GST_peer_list[p2]->details.remote.slave->controller;
1594  }
1596  occq_tail,
1597  occ);
1598  occ->client = client;
1599  occ->other_peer_id = p2;
1601  occ->peer = GST_peer_list[p1];
1602  occ->op_id = operation_id;
1603  GNUNET_assert (NULL == occ->timeout_task);
1604  occ->timeout_task =
1607  occ);
1608  switch (occ->type)
1609  {
1611  GNUNET_asprintf (&occ->emsg,
1612  "0x%llx: Timeout while acquiring connection to peer %u's "
1613  "host: %u\n",
1614  occ->op_id,
1615  occ->other_peer_id,
1616  peer2_host_id);
1617  occ->p2ctx.remote.ncn
1620  occ);
1621  break;
1622 
1623  case OCC_TYPE_REMOTE_SLAVE:
1625  occ->p2ctx.remote.p2c);
1626  break;
1627 
1628  case OCC_TYPE_LOCAL:
1629  peer2 = GST_peer_list[occ->other_peer_id];
1630  peer2->reference_cnt++;
1632  &occ->other_peer_identity);
1633  GNUNET_asprintf (&occ->emsg,
1634  "0x%llx: Timeout while connecting to CORE of peer with "
1635  "id: %u",
1636  occ->op_id,
1637  occ->peer->id);
1638  occ->cgh_ch =
1640  occ->peer->details.local.cfg,
1643  &occ->other_peer_identity,
1644  &overlay_connect_notify, occ);
1645  break;
1646  }
1648 }
A connected controller which is not our child.
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.
int is_remote
Is this peer locally created?
struct NeighbourConnectNotification * ncn
Notification handle acquire to connect to a remote controller.
uint64_t op_id
The id of the operation responsible for creating this context.
Type to be used when the first peer is local and the other peer is on a controller which is not start...
struct GST_ConnectionPool_GetHandle * cgh_ch
The GST_ConnectionPool_GetHandle for registering callback to notify CORE level peer connects and to g...
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
Context information for connecting 2 peers in overlay.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t id
Our local reference id for this peer.
#define VALID_PEER_ID(id)
Condition to check if peer id is valid.
struct Peer ** GST_peer_list
A list of peers we know about.
uint64_t operation_id
Operation ID that is used to identify this operation.
Definition: testbed.h:390
#define LOG(kind,...)
Redefine LOG with a changed log component string.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
char * emsg
The error message we send if this overlay connect operation has timed out.
struct Peer::@66::@68 remote
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void timeout_overlay_connect(void *cls)
Task which will be run when overlay connect request has been timed out.
struct GNUNET_SERVICE_Client * client
The client which has requested for overlay connection.
Handle to a client that is connected to a service.
Definition: service.c:250
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.
struct GNUNET_TESTBED_Controller * p2c
Controller of peer 2; If OCC_TYPE_REMOTE_LATERAL is the type of overlay connection then this can be N...
static struct OverlayConnectContext * occq_tail
DLL tail for OverlayConnectContext DLL.
uint32_t peer2
Unique ID for the second peer.
Definition: testbed.h:395
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
uint32_t peer1
Unique ID for the first peer.
Definition: testbed.h:385
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
uint32_t peer2_host_id
The ID of the host which runs peer2.
Definition: testbed.h:400
enum OverlayConnectContextType type
The type of this context information.
struct Neighbour * p2n
The neighbour handle.
union Peer::@66 details
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
uint32_t reference_cnt
References to peers are using in forwarded overlay contexts and remote overlay connect contexts...
This type is used if the overlay connection is local i.e.
static struct OverlayConnectContext * occq_head
DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct Peer::@66::@67 local
Type to be used when the first peer is local and the other peer is on a slave controller started by u...
#define VALID_HOST_ID(id)
Condition to check if host id is valid.
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
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.
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
void GNUNET_TESTING_peer_get_identity(struct GNUNET_TESTING_Peer *peer, struct GNUNET_PeerIdentity *id)
Obtain the peer identity from a peer handle.
Definition: testing.c:1337
union OverlayConnectContext::@69 p2ctx
Context information for operations on the second peer.
#define GNUNET_YES
Definition: gnunet_common.h:77
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.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define LOG_DEBUG(...)
Debug logging shorthand.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_free(ptr)
Wrapper around free.
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
roccthe RemoteOverlayConnectCtx

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

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_free_non_null, 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, 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().

1659 {
1660  LOG_DEBUG ("0x%llx: Cleaning up rocc\n",
1661  rocc->op_id);
1662  if (NULL != rocc->attempt_connect_task_id)
1664  if (NULL != rocc->timeout_rocc_task_id)
1666  if (NULL != rocc->ohh)
1668  if (NULL != rocc->tcc.csh)
1672  GNUNET_assert (rocc->peer->reference_cnt > 0);
1673  rocc->peer->reference_cnt--;
1674  if ((GNUNET_YES == rocc->peer->destroy_flag) &&
1675  (0 == rocc->peer->reference_cnt))
1676  GST_destroy_peer (rocc->peer);
1677  GNUNET_free_non_null (rocc->hello);
1679  roccq_tail,
1680  rocc);
1681  GNUNET_free (rocc);
1682 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static struct RemoteOverlayConnectCtx * roccq_head
DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown.
uint32_t destroy_flag
While destroying a peer, due to the fact that there could be references to this peer, we delay the peer destroy to a further time.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct ConnectivitySuggestContext tcc
The transport try connect context.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering HELLO.
struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id
Task to timeout RequestOverlayConnect.
static struct RemoteOverlayConnectCtx * roccq_tail
DLL tail for RequectOverlayConnectContext DLL.
uint64_t op_id
The id of the operation responsible for creating this context.
uint32_t reference_cnt
References to peers are using in forwarded overlay contexts and remote overlay connect contexts...
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_ATS_ConnectivitySuggestHandle * csh
The ATS handle for the connectivity suggestion.
void GST_destroy_peer(struct Peer *peer)
Function to destroy a peer.
struct GNUNET_MessageHeader * hello
Peer A's HELLO.
struct GST_ConnectionPool_GetHandle * cgh_p2_th
The GetCacheHandle for the peer2's transport handle (used to offer the HELLO to the peer)...
#define GNUNET_YES
Definition: gnunet_common.h:77
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
struct Peer * peer
The peer handle of peer B.
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_free(ptr)
Wrapper around free.
struct GST_ConnectionPool_GetHandle * cgh_p2_ats
The GetCacheHandle for the peer2's ATS handle.
struct GNUNET_SCHEDULER_Task * attempt_connect_task_id
Task for offering HELLO of A to B and doing try_connect.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsthe RemoteOverlayConnectCtx

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

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().

1692 {
1693  struct RemoteOverlayConnectCtx *rocc = cls;
1694 
1695  GNUNET_assert (rocc->timeout_rocc_task_id != NULL);
1696  rocc->timeout_rocc_task_id = NULL;
1697  LOG_DEBUG ("0x%llx: rocc timed out\n",
1698  rocc->op_id);
1699  cleanup_rocc (rocc);
1700 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.
struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id
Task to timeout RequestOverlayConnect.
uint64_t op_id
The id of the operation responsible for creating this context.
Context information for remote overlay connect operations.
#define LOG_DEBUG(...)
Debug logging shorthand.
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
clsthe RemoteOverlayConnectContext
new_peerthe peer that connected

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

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

Referenced by handle_remote_overlay_connect().

1713 {
1714  struct RemoteOverlayConnectCtx *rocc = cls;
1715 
1716  LOG_DEBUG ("0x%llx: Request Overlay connect notify\n",
1717  rocc->op_id);
1718  GNUNET_assert (0 ==
1719  memcmp (new_peer, &rocc->a_id,
1720  sizeof(struct GNUNET_PeerIdentity)));
1721  LOG_DEBUG ("0x%llx: Peer %s connected\n",
1722  rocc->op_id,
1723  GNUNET_i2s (&rocc->a_id));
1724  cleanup_rocc (rocc);
1725 }
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.
uint64_t op_id
The id of the operation responsible for creating this context.
Context information for remote overlay connect operations.
The identity of the host (wraps the signing key of the peer).
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG_DEBUG(...)
Debug logging shorthand.
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
clsthe RemoteOverlayConnectCtx

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

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 cache_transport_peer_connect_notify(), and rocc_cache_get_handle_transport_cb().

1773 {
1774  struct RemoteOverlayConnectCtx *rocc = cls;
1775 
1776  GNUNET_assert (NULL != rocc->attempt_connect_task_id);
1777  rocc->attempt_connect_task_id = NULL;
1778  LOG_DEBUG ("0x%llx: Offering HELLO of peer %s to remote peer with id: %u\n",
1779  rocc->op_id,
1780  GNUNET_i2s (&rocc->a_id),
1781  rocc->peer->id);
1782  rocc->ohh =
1784  rocc->hello,
1786  rocc);
1787  if (NULL == rocc->ohh)
1788  rocc->attempt_connect_task_id =
1791  100
1794  &attempt_connect_task, rocc);
1795 }
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
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 Re...
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t id
Our local reference id for this peer.
struct ConnectivitySuggestContext tcc
The transport try connect context.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering HELLO.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration of the peer from cache.
uint64_t op_id
The id of the operation responsible for creating this context.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
Context information for remote overlay connect operations.
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 sendin...
struct GNUNET_TRANSPORT_OfferHelloHandle * GNUNET_TRANSPORT_offer_hello(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_MessageHeader *hello, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Offer the transport service the HELLO of another peer.
struct GNUNET_MessageHeader * hello
Peer A's HELLO.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct Peer * peer
The peer handle of peer B.
#define LOG_DEBUG(...)
Debug logging shorthand.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
struct GNUNET_SCHEDULER_Task * attempt_connect_task_id
Task for offering HELLO of A to B and doing try_connect.
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
clsthe overlay connect context

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

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().

1747 {
1748  struct RemoteOverlayConnectCtx *rocc = cls;
1749 
1750  rocc->ohh = NULL;
1751  GNUNET_assert (NULL == rocc->attempt_connect_task_id);
1752  LOG_DEBUG ("0x%llx: HELLO of peer %s delivered to local peer with id: %u\n",
1753  rocc->op_id,
1754  GNUNET_i2s (&rocc->a_id),
1755  rocc->peer->id);
1756  rocc->tcc.cgh_p2_ats =
1758  rocc->peer->details.local.cfg,
1761  rocc, NULL, NULL, NULL);
1762 }
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t id
Our local reference id for this peer.
struct ConnectivitySuggestContext tcc
The transport try connect context.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering HELLO.
uint64_t op_id
The id of the operation responsible for creating this context.
union Peer::@66 details
Context information for remote overlay connect operations.
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.
struct Peer::@66::@67 local
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct Peer * peer
The peer handle of peer B.
#define LOG_DEBUG(...)
Debug logging shorthand.
struct GST_ConnectionPool_GetHandle * cgh_p2_ats
The GetCacheHandle for the peer2's ATS handle.
struct GNUNET_SCHEDULER_Task * attempt_connect_task_id
Task for offering HELLO of A to B and doing try_connect.
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
clsthe closure passed to GST_cache_get_handle_transport()
chthe handle to CORE. Can be NULL if it is not requested
ththe handle to TRANSPORT. Can be NULL if it is not requested
acthe handle to ATS. Can be NULL if it is not requested
ignore_peer identity which is ignored in this callback

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

References RemoteOverlayConnectCtx::a_id, attempt_connect_task(), RemoteOverlayConnectCtx::attempt_connect_task_id, 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().

1815 {
1816  struct RemoteOverlayConnectCtx *rocc = cls;
1817 
1818  if (NULL == th)
1819  {
1820  rocc->timeout_rocc_task_id =
1822  return;
1823  }
1824  rocc->tcc.th_ = th;
1825  rocc->tcc.cfg = cfg;
1826  if (NULL !=
1828  &rocc->a_id))
1829  {
1830  LOG_DEBUG ("0x%llx: Target peer %s already connected to local peer: %u\n",
1831  rocc->op_id,
1832  GNUNET_i2s (&rocc->a_id),
1833  rocc->peer->id);
1834  cleanup_rocc (rocc);
1835  return;
1836  }
1837  rocc->attempt_connect_task_id =
1839 }
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
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 Re...
uint32_t id
Our local reference id for this peer.
struct ConnectivitySuggestContext tcc
The transport try connect context.
static void cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.
struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id
Task to timeout RequestOverlayConnect.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration of the peer from cache.
uint64_t op_id
The id of the operation responsible for creating this context.
Context information for remote overlay connect operations.
struct GNUNET_MQ_Handle * GNUNET_TRANSPORT_core_get_mq(struct GNUNET_TRANSPORT_CoreHandle *handle, const struct GNUNET_PeerIdentity *peer)
Checks if a given peer is connected to us and get the message queue.
static void timeout_rocc_task(void *cls)
Task to timeout rocc and cleanit up.
struct GNUNET_TRANSPORT_CoreHandle * th_
The transport handle obtained from cache.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct Peer * peer
The peer handle of peer B.
#define LOG_DEBUG(...)
Debug logging shorthand.
struct GNUNET_SCHEDULER_Task * attempt_connect_task_id
Task for offering HELLO of A to B and doing try_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
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

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

References GNUNET_break, GNUNET_break_op, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_OK, GNUNET_SYSERR, GST_peer_list, GST_peer_list_size, GNUNET_TESTBED_RemoteOverlayConnectMessage::header, GNUNET_TESTBED_RemoteOverlayConnectMessage::hello, GNUNET_TESTBED_RemoteOverlayConnectMessage::peer, peer_id, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

1853 {
1854  uint32_t peer_id;
1855  uint16_t msize;
1856  uint16_t hsize;
1857 
1858  msize = ntohs (msg->header.size);
1859  if (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type))
1860  {
1861  GNUNET_break (0);
1862  return GNUNET_SYSERR;
1863  }
1864  hsize = ntohs (msg->hello->size);
1865  if ((sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) !=
1866  msize)
1867  {
1868  GNUNET_break (0);
1869  return GNUNET_SYSERR;
1870  }
1871  peer_id = ntohl (msg->peer);
1872  if ((peer_id >= GST_peer_list_size) ||
1873  (NULL == GST_peer_list[peer_id]))
1874  {
1875  GNUNET_break_op (0);
1876  return GNUNET_SYSERR;
1877  }
1878  return GNUNET_OK;
1879 }
Message sent from host controller of a peer(A) to the host controller of another peer(B) to request B...
Definition: testbed.h:408
struct Peer ** GST_peer_list
A list of peers we know about.
unsigned int GST_peer_list_size
The size of the peer list.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
struct GNUNET_MessageHeader hello[0]
To be followed by the HELLO message of A.
Definition: testbed.h:433
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint32_t peer
The Unique ID of B.
Definition: testbed.h:418
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_MESSAGE_TYPE_HELLO
HELLO message with friend only flag used for communicating peer addresses.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT.
Definition: testbed.h:413

◆ 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
clsidentification of the client
msgthe actual message

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

References RemoteOverlayConnectCtx::a_id, cache_transport_peer_connect_notify(), ConnectivitySuggestContext::cgh_p2_th, 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, GNUNET_TESTBED_RemoteOverlayConnectMessage::header, RemoteOverlayConnectCtx::hello, GNUNET_TESTBED_RemoteOverlayConnectMessage::hello, Peer::is_remote, Peer::local, LOG_DEBUG, RemoteOverlayConnectCtx::op_id, GNUNET_TESTBED_RemoteOverlayConnectMessage::operation_id, peer, RemoteOverlayConnectCtx::peer, GNUNET_TESTBED_RemoteOverlayConnectMessage::peer, peer_id, GNUNET_TESTBED_RemoteOverlayConnectMessage::peer_identity, Peer::reference_cnt, Peer::remote, rocc_cache_get_handle_transport_cb(), GNUNET_MessageHeader::size, RemoteOverlayConnectCtx::tcc, timeout_rocc_task(), and RemoteOverlayConnectCtx::timeout_rocc_task_id.

1892 {
1893  struct GNUNET_SERVICE_Client *client = cls;
1894  struct RemoteOverlayConnectCtx *rocc;
1895  struct Peer *peer;
1896  struct GNUNET_PeerIdentity pid;
1897  static char pid_str[16];
1898  uint32_t peer_id;
1899  uint16_t hsize;
1900 
1901  hsize = ntohs (msg->hello->size);
1902  peer_id = ntohl (msg->peer);
1903  peer = GST_peer_list[peer_id];
1904  if (GNUNET_YES == peer->is_remote)
1905  {
1906  struct GNUNET_MessageHeader *msg2;
1907 
1908  msg2 = GNUNET_copy_message (&msg->header);
1909  GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller,
1910  msg2);
1912  return;
1913  }
1914  rocc = GNUNET_new (struct RemoteOverlayConnectCtx);
1915  rocc->op_id = GNUNET_ntohll (msg->operation_id);
1917  roccq_tail,
1918  rocc);
1919  rocc->a_id = msg->peer_identity;
1921  &pid);
1922  (void) GNUNET_strlcpy (pid_str,
1923  GNUNET_i2s (&pid),
1924  sizeof(pid_str));
1925  LOG_DEBUG (
1926  "0x%llx: Remote overlay connect %s to peer %s with hello size: %u\n",
1927  rocc->op_id,
1928  pid_str,
1929  GNUNET_i2s (&rocc->a_id),
1930  hsize);
1931  rocc->peer = peer;
1932  rocc->peer->reference_cnt++;
1933  rocc->hello = GNUNET_malloc (hsize);
1934  GNUNET_memcpy (rocc->hello,
1935  msg->hello,
1936  hsize);
1937  rocc->tcc.cgh_p2_th =
1939  rocc->peer->details.local.cfg,
1942  rocc,
1943  &rocc->a_id,
1945  rocc);
1946  rocc->timeout_rocc_task_id =
1949  rocc);
1951 }
static struct RemoteOverlayConnectCtx * roccq_head
DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown.
int is_remote
Is this peer locally created?
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.
struct ConnectivitySuggestContext tcc
The transport try connect context.
struct Peer ** GST_peer_list
A list of peers we know about.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
struct GNUNET_MessageHeader hello[0]
To be followed by the HELLO message of A.
Definition: testbed.h:433
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_PeerIdentity peer_identity
Identity of A.
Definition: testbed.h:428
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct Peer::@66::@68 remote
Handle to a client that is connected to a service.
Definition: service.c:250
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
uint32_t peer
The Unique ID of B.
Definition: testbed.h:418
struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id
Task to timeout RequestOverlayConnect.
static struct RemoteOverlayConnectCtx * roccq_tail
DLL tail for RequectOverlayConnectContext DLL.
uint64_t operation_id
The Operation ID that is used to identify this operation.
Definition: testbed.h:423
uint64_t op_id
The id of the operation responsible for creating this context.
union Peer::@66 details
uint32_t reference_cnt
References to peers are using in forwarded overlay contexts and remote overlay connect contexts...
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.
Context information for remote overlay connect operations.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
void GNUNET_TESTBED_queue_message_(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_MessageHeader *msg)
Queues a message in send queue for sending to the service.
Definition: testbed_api.c:1335
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct Peer::@66::@67 local
The identity of the host (wraps the signing key of the peer).
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
struct GST_ConnectionPool_GetHandle * GST_connection_pool_get_handle(unsigned int peer_id, const struct GNUNET_CONFIGURATION_Handle *cfg, enum GST_ConnectionPool_Service service, GST_connection_pool_connection_ready_cb cb, void *cb_cls, const struct GNUNET_PeerIdentity *target, GST_connection_pool_peer_connect_notify connect_notify_cb, void *connect_notify_cb_cls)
Get a connection handle to service.
void GNUNET_TESTING_peer_get_identity(struct GNUNET_TESTING_Peer *peer, struct GNUNET_PeerIdentity *id)
Obtain the peer identity from a peer handle.
Definition: testing.c:1337
struct GNUNET_MessageHeader * hello
Peer A's HELLO.
Header for all communications.
struct GST_ConnectionPool_GetHandle * cgh_p2_th
The GetCacheHandle for the peer2's transport handle (used to offer the HELLO to the peer)...
#define GNUNET_YES
Definition: gnunet_common.h:77
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.
static void timeout_rocc_task(void *cls)
Task to timeout rocc and cleanit up.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
Definition: strings.c:219
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
struct Peer * peer
The peer handle of peer B.
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_malloc(size)
Wrapper around malloc.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT.
Definition: testbed.h:413
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
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 1958 of file gnunet-service-testbed_oc.c.

References cleanup_occ().

Referenced by handle_shutdown_peers(), and shutdown_task().

1959 {
1960  struct OverlayConnectContext *occ;
1961 
1962  while (NULL != (occ = occq_head))
1963  cleanup_occ (occ);
1964 }
Context information for connecting 2 peers in overlay.
static void cleanup_occ(struct OverlayConnectContext *occ)
Cleanup overlay connect context structure.
static struct OverlayConnectContext * occq_head
DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.
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 1971 of file gnunet-service-testbed_oc.c.

References cleanup_rocc().

Referenced by handle_shutdown_peers(), and shutdown_task().

1972 {
1973  struct RemoteOverlayConnectCtx *rocc;
1974 
1975  while (NULL != (rocc = roccq_head))
1976  cleanup_rocc (rocc);
1977 }
static struct RemoteOverlayConnectCtx * roccq_head
DLL head for RequectOverlayConnectContext DLL - to be used to clean up during shutdown.
static void cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.
Context information for remote overlay connect operations.
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 331 of file gnunet-service-testbed_oc.c.

◆ occq_tail

struct OverlayConnectContext* occq_tail
static

DLL tail for OverlayConnectContext DLL.

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

◆ roccq_head

struct RemoteOverlayConnectCtx* roccq_head
static

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

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

◆ roccq_tail

struct RemoteOverlayConnectCtx* roccq_tail
static

DLL tail for RequectOverlayConnectContext DLL.

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