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 successful. More...
 
void GST_process_next_focc (struct RegisteredHostContext *rhc)
 Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext. More...
 
static void cleanup_occ_lp2c (struct LocalPeer2Context *lp2c)
 Cleans up any used handles in local peer2 context. More...
 
static void cleanup_occ_rp2c (struct RemotePeer2Context *rp2c)
 Cleans up any used handles in remote peer2 context. More...
 
static void cleanup_occ (struct OverlayConnectContext *occ)
 Cleanup overlay connect context structure. More...
 
static void do_cleanup_occ (void *cls)
 Task for cleaning up overlay connect context structure. More...
 
static void timeout_overlay_connect (void *cls)
 Task which will be run when overlay connect request has been timed out. More...
 
void GST_notify_client_disconnect_oc (struct GNUNET_SERVICE_Client *client)
 Notify OC subsystem that client disconnected. More...
 
static void send_overlay_connect_success_msg (struct OverlayConnectContext *occ)
 FIXME. More...
 
static void overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
 Function called to notify transport users that another peer connected to us. More...
 
static void occ_cache_get_handle_ats_occ_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Callback from cache with needed ATS handle set. More...
 
static void occ_cache_get_handle_ats_rocc_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Callback from cache with needed ATS handle set. More...
 
static void send_hello (void *cls)
 Task to offer HELLO of peer 1 to peer 2 and try to make peer 2 to connect to peer 1. More...
 
static void occ_hello_sent_cb (void *cls)
 Task that is run when hello has been sent If tc->reason = GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if GNUNET_SCHEDULER_REASON_READ_READY is succeeded. More...
 
static void send_hello_thru_rocc (struct OverlayConnectContext *occ)
 Sends the HELLO of peer1 to peer2's controller through remote overlay connect request. More...
 
static void p2_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Callback from cache with needed handles set. More...
 
static void p2_transport_connect (struct OverlayConnectContext *occ)
 Connects to the transport of the other peer if it is a local peer and schedules the send hello task. More...
 
static int test_address (void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Absolute expiration)
 Test for checking whether HELLO message is empty. More...
 
static void hello_update_cb (void *cls, const struct GNUNET_MessageHeader *hello)
 Function called whenever there is an update to the HELLO of peers in the OverlayConnectClosure. More...
 
static void p1_transport_connect_cache_callback (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *ignore_, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Callback from cache with needed handles set. More...
 
static void occ_cache_get_handle_core_cb (void *cls, struct GNUNET_CORE_Handle *ch, struct GNUNET_TRANSPORT_CoreHandle *th, struct GNUNET_ATS_ConnectivityHandle *ac, const struct GNUNET_PeerIdentity *my_identity, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Callback from cache with needed CORE handle set. More...
 
static void overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg)
 Callback to be called when forwarded get peer config operation as part of overlay connect is successful. More...
 
static void host_registration_comp (void *cls, const char *emsg)
 Callback which will be called after a host registration succeeded or failed. More...
 
static int reghost_match_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator to match a registered host context. More...
 
static struct GNUNET_HashCode hash_hosts (struct GNUNET_TESTBED_Host *reg_host, struct GNUNET_TESTBED_Host *host)
 Function to generate the hashcode corresponding to a RegisteredHostContext. More...
 
static struct 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.

◆ 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.

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 };
@ OCC_TYPE_LOCAL
This type is used if the overlay connection is local i.e.
@ 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 start...
@ 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 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.

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

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

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

Here is the caller graph for this function:

◆ forwarded_overlay_connect_timeout()

static void forwarded_overlay_connect_timeout ( void *  cls)
static

Timeout task for cancelling a forwarded overlay connect connect.

Parameters
clsthe struct ForwardedOperationContext

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

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)
390 }
#define LOG_DEBUG(...)
Debug logging shorthand.
void GST_forwarded_operation_timeout(void *cls)
Task to free resources when forwarded operation has been timed out.
void GST_cleanup_focc(struct ForwardedOverlayConnectContext *focc)
Cleans up ForwardedOverlayConnectContext.
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.
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
Context information to used during operations which forward the overlay connect message.

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

Referenced by GST_process_next_focc().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ forwarded_overlay_connect_listener()

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

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

We have to relay the reply msg back to the client

Parameters
clsForwardedOperationContext
msgthe peer create success message

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

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)
415 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
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.

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

Referenced by GST_process_next_focc().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GST_process_next_focc()

void GST_process_next_focc ( struct RegisteredHostContext rhc)

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

Parameters
rhcthe RegisteredHostContext

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

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];
436  GNUNET_assert (GNUNET_YES == peer->is_remote);
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 ForwardedOperationContext * fopcq_head
DLL head for forwarded operation contexts.
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
struct ForwardedOperationContext * fopcq_tail
DLL tail for forwarded operation contexts.
#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.
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...
static void forwarded_overlay_connect_timeout(void *cls)
Timeout task for cancelling a forwarded overlay connect connect.
@ GNUNET_YES
Definition: gnunet_common.h:97
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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:1269
enum OperationType type
The type of the operation which is forwarded.
struct OperationContext * opc
The generated operation context.
struct GNUNET_SERVICE_Client * client
The client to which we have to reply.
uint64_t operation_id
The id of the operation that has been forwarded.
uint64_t operation_id
The id of the operation which created this context information.
struct GNUNET_SERVICE_Client * client
The client handle.
enum RegisteredHostContext::RHCState state
Structure representing a connected(directly-linked) controller.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
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:1370
@ OP_OVERLAY_CONNECT
Overlay connection operation.
Definition: testbed_api.h:79
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_occ_lp2c()

static void cleanup_occ_lp2c ( struct LocalPeer2Context lp2c)
static

Cleans up any used handles in local peer2 context.

Parameters
lp2cthe local peer2 context information

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

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 }
void GST_connection_pool_get_handle_done(struct GST_ConnectionPool_GetHandle *gh)
Relinquish a GST_ConnectionPool_GetHandle object.
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 GST_ConnectionPool_GetHandle * cgh_p2_ats
The GetCacheHandle for the peer2's ATS handle.
struct GST_ConnectionPool_GetHandle * cgh_p2_th
The GetCacheHandle for the peer2's transport handle (used to offer the HELLO to the peer).
struct GNUNET_ATS_ConnectivitySuggestHandle * csh
The ATS handle for the connectivity suggestion.
struct ConnectivitySuggestContext tcc
The transport ConnectivitySuggestContext.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering the HELLO of the first peer to the second peer.

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

Referenced by cleanup_occ(), and overlay_connect_notify().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_occ_rp2c()

static void cleanup_occ_rp2c ( struct RemotePeer2Context rp2c)
static

Cleans up any used handles in remote peer2 context.

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

Parameters
rp2cthe remote peer2 context information

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

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 Neighbour * p2n
The neighbour handle.
struct NeighbourConnectNotification * ncn
Notification handle acquire to connect to a remote controller.
struct OperationContext * opc
Operation context for the suboperation we start to get the identity of the second peer.
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:1407

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

Referenced by cleanup_occ(), and overlay_connect_notify().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_occ()

static void cleanup_occ ( struct OverlayConnectContext occ)
static

Cleanup overlay connect context structure.

Parameters
occthe overlay connect context

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

534 {
535  struct Peer *peer2;
536 
537  LOG_DEBUG ("0x%llx: Cleaning up occ\n",
538  (unsigned long long) occ->op_id);
539  GNUNET_free (occ->emsg);
540  GNUNET_free (occ->hello);
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 }
void GST_destroy_peer(struct Peer *peer)
Function to destroy a peer.
static void cleanup_occ_lp2c(struct LocalPeer2Context *lp2c)
Cleans up any used handles in local peer2 context.
static struct OverlayConnectContext * occq_tail
DLL tail for OverlayConnectContext DLL.
static struct OverlayConnectContext * occq_head
DLL head for OverlayConnectContext DLL - to be used to clean up during shutdown.
#define PEER_EXPIRED(peer)
Condition for checking if given peer is ready to be destroyed.
static void cleanup_occ_rp2c(struct RemotePeer2Context *rp2c)
Cleans up any used handles in remote peer2 context.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
struct GNUNET_MessageHeader * hello
HELLO of the first peer.
struct RemotePeer2Context remote
Context information to be used if the second peer is remote.
struct LocalPeer2Context local
Context information to be used if the second peer is local.
uint64_t op_id
The id of the operation responsible for creating this context.
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 GST_ConnectionPool_GetHandle * cgh_ch
The GST_ConnectionPool_GetHandle for registering callback to notify CORE level peer connects and to g...
union OverlayConnectContext::@60 p2ctx
Context information for operations on the second peer.
struct GNUNET_SCHEDULER_Task * cleanup_task
The id of the cleanup task.
enum OverlayConnectContextType type
The type of this context information.
struct Peer * peer
the first peer which is to expect an overlay connection from the second peer.
uint32_t other_peer_id
The id of the second peer which has to connect to the first peer.
struct GNUNET_SCHEDULER_Task * timeout_task
The id of the overlay connect timeout task.
char * emsg
The error message we send if this overlay connect operation has timed out.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Get GetHelloHandle to acquire a HELLO of the first peer.
struct GST_ConnectionPool_GetHandle * cgh_p1th
The GST_ConnectionPool_GetHandle for the peer1's transport handle.
uint32_t reference_cnt
References to peers are using in forwarded overlay contexts and remote overlay connect contexts.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_cleanup_occ()

static void do_cleanup_occ ( void *  cls)
static

Task for cleaning up overlay connect context structure.

Parameters
clsthe overlay connect context

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

587 {
588  struct OverlayConnectContext *occ = cls;
589 
590  occ->cleanup_task = NULL;
591  cleanup_occ (occ);
592 }
static void cleanup_occ(struct OverlayConnectContext *occ)
Cleanup overlay connect context structure.
Context information for connecting 2 peers in overlay.

References cleanup_occ(), and OverlayConnectContext::cleanup_task.

Referenced by occ_cache_get_handle_core_cb(), and overlay_connect_notify().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ timeout_overlay_connect()

static void timeout_overlay_connect ( void *  cls)
static

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

Parameters
clsthe OverlayConnectContext

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

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 }
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_SERVICE_Client * client
The client which has requested for overlay connection.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GST_notify_client_disconnect_oc()

void GST_notify_client_disconnect_oc ( struct GNUNET_SERVICE_Client client)

Notify OC subsystem that client disconnected.

Parameters
clientthe client that disconnected

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

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 ForwardedOperationContext * next
The next pointer for DLL.
struct OverlayConnectContext * next
The next pointer for maintaining a DLL of all OverlayConnectContexts.

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

Referenced by client_disconnect_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_overlay_connect_success_msg()

static void send_overlay_connect_success_msg ( struct OverlayConnectContext occ)
static

FIXME.

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

654 {
655  struct GNUNET_MQ_Envelope *env;
657 
658  LOG_DEBUG ("0x%llx: Peers connected - Sending overlay connect success\n",
659  (unsigned long long) 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 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
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:302
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#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:2442
@ GNUNET_TESTBED_ET_CONNECT
A connection between two peers was established.
Event notification from a controller to a client.
Definition: testbed.h:476
uint32_t id
Our local reference id for this peer.

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

Referenced by occ_cache_get_handle_core_cb(), and overlay_connect_notify().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ overlay_connect_notify()

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

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

Parameters
clsclosure
new_peerthe peer that connected

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

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  GNUNET_memcmp (new_peer,
689  &occ->peer_identity))
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  GNUNET_memcmp (new_peer,
695  &occ->other_peer_identity))
696  {
697  LOG_DEBUG ("Unexpected peer %s connected when expecting peer %s\n",
698  new_peer_str,
699  other_peer_str);
700  GNUNET_free (new_peer_str);
701  GNUNET_free (other_peer_str);
702  return;
703  }
704  GNUNET_free (new_peer_str);
705  LOG_DEBUG ("0x%llx: Peer %s connected to peer %s\n",
706  (unsigned long long) occ->op_id,
707  other_peer_str,
708  GNUNET_i2s (&occ->peer_identity));
709  GNUNET_free (other_peer_str);
710  if (NULL != occ->send_hello_task)
711  {
713  occ->send_hello_task = NULL;
714  }
715  GNUNET_assert (NULL != occ->timeout_task);
717  occ->timeout_task = NULL;
718  switch (occ->type)
719  {
720  case OCC_TYPE_LOCAL:
721  cleanup_occ_lp2c (&occ->p2ctx.local);
722  break;
723 
726  cleanup_occ_rp2c (&occ->p2ctx.remote);
727  break;
728  }
729  GNUNET_free (occ->emsg);
730  occ->emsg = NULL;
733  occ);
734 }
static void send_overlay_connect_success_msg(struct OverlayConnectContext *occ)
FIXME.
static void do_cleanup_occ(void *cls)
Task for cleaning up overlay connect context structure.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#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:1296
struct GNUNET_PeerIdentity other_peer_identity
The peer identity of the other peer.
struct GNUNET_PeerIdentity peer_identity
The peer identity of the first peer.

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

Referenced by handle_overlay_connect(), and overlay_connect_get_config().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ occ_cache_get_handle_ats_occ_cb()

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

Callback from cache with needed ATS handle set.

Parameters
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 748 of file gnunet-service-testbed_oc.c.

754 {
755  struct OverlayConnectContext *occ = cls;
756  struct LocalPeer2Context *lp2c;
757 
759  GNUNET_assert (NULL != occ->timeout_task);
760  GNUNET_free (occ->emsg);
761  if (NULL == ac)
762  {
763  GNUNET_asprintf (&occ->emsg,
764  "0x%llx: Failed to connect to ATS of peer with id: %u",
765  (unsigned long long) occ->op_id,
766  occ->peer->id);
768  occ->timeout_task =
770  occ);
771  return;
772  }
773  occ->emsg = NULL;
774 
775  GNUNET_asprintf (&occ->emsg,
776  "0x%llx: Timeout during GNUNET_ATS_connectivity_suggest() at peer %s",
777  (unsigned long long) occ->op_id,
779 
780  lp2c = &occ->p2ctx.local;
781  lp2c->tcc.csh =
783  &occ->peer_identity,
784  1);
785 }
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
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 int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
Context data for operations on second peer in local overlay connection contexts.

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

Referenced by occ_hello_sent_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ occ_cache_get_handle_ats_rocc_cb()

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

Callback from cache with needed ATS handle set.

Parameters
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 798 of file gnunet-service-testbed_oc.c.

804 {
805  struct RemoteOverlayConnectCtx *rocc = cls;
806 
807  rocc->tcc.csh =
809  &rocc->a_id,
810  1);
811 }
Context information for remote overlay connect operations.
struct ConnectivitySuggestContext tcc
The transport try connect context.
struct GNUNET_PeerIdentity a_id
The peer identity of peer A.

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

Referenced by rocc_hello_sent_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_hello()

static void send_hello ( void *  cls)
static

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

Task to offer HELLO of peer 1 to peer 2.

Parameters
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 911 of file gnunet-service-testbed_oc.c.

912 {
913  struct OverlayConnectContext *occ = cls;
914  struct LocalPeer2Context *lp2c;
915  char *other_peer_str;
916 
917  occ->send_hello_task = NULL;
918  GNUNET_assert (NULL != occ->timeout_task);
919  GNUNET_assert (NULL != occ->hello);
920  if (OCC_TYPE_LOCAL != occ->type)
921  {
922  send_hello_thru_rocc (occ);
923  return;
924  }
925  lp2c = &occ->p2ctx.local;
926  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
927  LOG_DEBUG ("0x%llx: Offering HELLO of %s to %s\n",
928  (unsigned long long) occ->op_id,
929  GNUNET_i2s (&occ->peer_identity),
930  other_peer_str);
931  GNUNET_free (other_peer_str);
932  lp2c->ohh =
934  occ->hello,
936  occ);
937  if (NULL == lp2c->ohh)
938  {
939  GNUNET_break (0);
940  occ->send_hello_task =
943  100
946  &send_hello, occ);
947  }
948 }
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.
static void send_hello_thru_rocc(struct OverlayConnectContext *occ)
Sends the HELLO of peer1 to peer2's controller through remote overlay connect request.
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...
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
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:483
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.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration of the peer from cache.

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

Referenced by p2_transport_connect(), and p2_transport_connect_cache_callback().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ occ_hello_sent_cb()

static void occ_hello_sent_cb ( void *  cls)
static

Task that is run when hello has been sent If tc->reason = GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if GNUNET_SCHEDULER_REASON_READ_READY is succeeded.

Parameters
clsthe overlay connect context

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

833 {
834  struct OverlayConnectContext *occ = cls;
835  struct LocalPeer2Context *lp2c;
836  struct Peer *peer2;
837 
839  GNUNET_assert (NULL != occ->timeout_task);
840  lp2c = &occ->p2ctx.local;
841  lp2c->ohh = NULL;
842 
843  GNUNET_assert (NULL == occ->send_hello_task);
844  GNUNET_free (occ->emsg);
845 
846  GNUNET_asprintf (&occ->emsg,
847  "0x%llx: Timeout while acquiring ATS of %s from cache",
848  (unsigned long long) occ->op_id,
850  GNUNET_assert (NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
851  lp2c->tcc.cgh_p2_ats =
853  peer2->details.local.cfg,
856  occ, NULL, NULL, NULL);
857 }
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.
@ GST_CONNECTIONPOOL_SERVICE_ATS_CONNECTIVITY
ATS service.
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.
union Peer::@57 details
struct Peer::@57::@58 local

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

Referenced by send_hello().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_hello_thru_rocc()

static void send_hello_thru_rocc ( struct OverlayConnectContext occ)
static

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

Parameters
occthe overlay connect context. Its type must be either OCC_TYPE_REMOTE_SLAVE or OCC_TYPE_REMOTE_LATERAL

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

869 {
871  char *other_peer_str;
872  uint16_t msize;
873  uint16_t hello_size;
874 
876  GNUNET_assert (NULL != occ->hello);
877  other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
878  LOG_DEBUG (
879  "0x%llx: Offering HELLO of %s (size: %u) to %s via Remote Overlay Request\n",
880  (unsigned long long) occ->op_id,
881  GNUNET_i2s (&occ->peer_identity),
882  ntohs (occ->hello->size),
883  other_peer_str);
884  GNUNET_free (other_peer_str);
885  hello_size = ntohs (occ->hello->size);
886  msize = sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage)
887  + hello_size;
888  msg = GNUNET_malloc (msize);
889  msg->header.type =
891  msg->header.size = htons (msize);
892  msg->peer = htonl (occ->other_peer_id);
893  msg->operation_id = GNUNET_htonll (occ->op_id);
894  msg->peer_identity = occ->peer_identity;
895  GNUNET_memcpy (msg->hello,
896  occ->hello,
897  hello_size);
899  &msg->header);
900 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_malloc(size)
Wrapper around malloc.
#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...
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Message sent from host controller of a peer(A) to the host controller of another peer(B) to request B...
Definition: testbed.h:409
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:1336

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

Referenced by send_hello().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ p2_transport_connect_cache_callback()

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

Callback from cache with needed handles set.

Parameters
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 962 of file gnunet-service-testbed_oc.c.

969 {
970  struct OverlayConnectContext *occ = cls;
971 
973  if (NULL == th)
974  {
975  GNUNET_asprintf (&occ->emsg,
976  "0x%llx: Cannot connect to TRANSPORT of %s",
977  (unsigned long long) occ->op_id,
980  occ->timeout_task =
982  return;
983  }
984  occ->p2ctx.local.tcc.th_ = th;
985  occ->p2ctx.local.tcc.cfg = cfg;
986  GNUNET_asprintf (&occ->emsg,
987  "0x%llx: Timeout while offering HELLO to %s",
988  (unsigned long long) occ->op_id,
991 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct GNUNET_TRANSPORT_CoreHandle * th_
The transport handle obtained from cache.

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

Referenced by p2_transport_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ p2_transport_connect()

static void p2_transport_connect ( struct OverlayConnectContext occ)
static

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

Parameters
occthe overlay connect context

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

1002 {
1003  struct Peer *peer2;
1004 
1005  /* HUH? Why to *obtain* HELLO? Seems we use this to *SEND* the
1006  HELLO! */
1008  "Connecting to transport of peer %s to obtain HELLO\n",
1010  GNUNET_assert (NULL == occ->emsg);
1011  GNUNET_assert (NULL != occ->hello);
1012  GNUNET_assert (NULL == occ->ghh);
1013  GNUNET_assert (NULL == occ->p1th_);
1014  GNUNET_assert (NULL == occ->cgh_p1th);
1015  if (OCC_TYPE_LOCAL == occ->type)
1016  {
1017  GNUNET_assert (NULL != (peer2 = GST_peer_list[occ->other_peer_id]));
1018  occ->p2ctx.local.tcc.cgh_p2_th =
1020  peer2->details.local.cfg,
1023  occ, NULL, NULL, NULL);
1024  return;
1025  }
1026  GNUNET_asprintf (&occ->emsg,
1027  "0x%llx: Timeout while offering HELLO to %s",
1028  (unsigned long long) occ->op_id,
1031 }
@ GST_CONNECTIONPOOL_SERVICE_TRANSPORT
Transport service.
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.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_TRANSPORT_CoreHandle * p1th_
Transport handle of the first peer obtained from cache to get its HELLO.

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

Referenced by hello_update_cb(), and occ_cache_get_handle_core_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ test_address()

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

Test for checking whether HELLO message is empty.

Parameters
clsempty flag to set
addressthe HELLO
expirationexpiration of the HELLO
Returns
GNUNET_OK

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

1046 {
1047  int *empty = cls;
1048 
1049  *empty = GNUNET_NO;
1050  return GNUNET_OK;
1051 }
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_NO
Definition: gnunet_common.h:94

References GNUNET_NO, and GNUNET_OK.

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

Here is the caller graph for this function:

◆ hello_update_cb()

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

Function called whenever there is an update to the HELLO of peers in the OverlayConnectClosure.

If we have a valid HELLO, we connect to the peer 2's transport and offer peer 1's HELLO and ask peer 2 to connect to peer 1

Parameters
clsclosure
helloour updated HELLO

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

1065 {
1066  struct OverlayConnectContext *occ = cls;
1067  int empty;
1068  uint16_t msize;
1069 
1070  msize = ntohs (hello->size);
1071  empty = GNUNET_YES;
1072  (void) GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *)
1073  hello, GNUNET_NO,
1074  &test_address,
1075  &empty);
1076  if (GNUNET_YES == empty)
1077  {
1078  LOG_DEBUG ("0x%llx: HELLO of %s is empty\n",
1079  (unsigned long long) occ->op_id,
1080  GNUNET_i2s (&occ->peer_identity));
1081  return;
1082  }
1083  LOG_DEBUG ("0x%llx: Received HELLO of %s\n",
1084  (unsigned long long) occ->op_id,
1085  GNUNET_i2s (&occ->peer_identity));
1086  occ->hello = GNUNET_malloc (msize);
1087  GST_cache_add_hello (occ->peer->id, hello);
1088  GNUNET_memcpy (occ->hello, hello, msize);
1090  occ->ghh = NULL;
1092  occ->cgh_p1th = NULL;
1093  occ->p1th_ = NULL;
1094  GNUNET_free (occ->emsg);
1095  occ->emsg = NULL;
1096  p2_transport_connect (occ);
1097 }
void GST_cache_add_hello(const unsigned int peer_id, const struct GNUNET_MessageHeader *hello)
Caches the HELLO of the given peer.
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.
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.
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
A HELLO message is used to exchange information about transports with other peers.

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

Referenced by p1_transport_connect_cache_callback().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ p1_transport_connect_cache_callback()

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

Callback from cache with needed handles set.

Parameters
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 1110 of file gnunet-service-testbed_oc.c.

1117 {
1118  struct OverlayConnectContext *occ = cls;
1119 
1120  GNUNET_free (occ->emsg);
1121  occ->emsg = NULL;
1122  if (NULL == th)
1123  {
1124  GNUNET_asprintf (&occ->emsg,
1125  "0x%llx: Cannot connect to TRANSPORT of %s",
1126  (unsigned long long) occ->op_id,
1127  GNUNET_i2s (&occ->peer_identity));
1129  occ->timeout_task =
1131  return;
1132  }
1133  GNUNET_assert (NULL == occ->p1th_);
1134  GNUNET_assert (NULL != occ->cgh_p1th);
1135  occ->p1th_ = th;
1136  GNUNET_asprintf (&occ->emsg,
1137  "0x%llx: Timeout while acquiring HELLO of peer %s",
1138  (unsigned long long) occ->op_id,
1139  GNUNET_i2s (&occ->peer_identity));
1142  &hello_update_cb,
1143  occ);
1144 }
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.
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.
@ GNUNET_TRANSPORT_AC_ANY
Bitmask for "any" address.

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

Referenced by occ_cache_get_handle_core_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ occ_cache_get_handle_core_cb()

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

Callback from cache with needed CORE handle set.

Parameters
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 1157 of file gnunet-service-testbed_oc.c.

1163 {
1164  struct OverlayConnectContext *occ = cls;
1165  const struct GNUNET_MessageHeader *hello;
1166 
1167  GNUNET_assert (NULL != occ->timeout_task);
1168  GNUNET_free (occ->emsg);
1169  if ((NULL == ch) || (NULL == my_identity))
1170  {
1171  GNUNET_asprintf (&occ->emsg,
1172  "0x%llx: Failed to connect to CORE of peer with "
1173  "id: %u",
1174  (unsigned long long) occ->op_id,
1175  occ->peer->id);
1177  occ->timeout_task =
1179  return;
1180  }
1181  occ->emsg = NULL;
1182  occ->peer_identity = *my_identity;
1183  if (NULL !=
1185  &occ->other_peer_identity))
1186  {
1187  LOG_DEBUG ("0x%llx: Target peer %s already connected\n",
1188  (unsigned long long) occ->op_id,
1190  LOG_DEBUG ("0x%llx: Target peer %s connected\n",
1191  (unsigned long long) occ->op_id,
1192  GNUNET_i2s (&occ->peer_identity));
1194  occ->timeout_task = NULL;
1197  return;
1198  }
1199  LOG_DEBUG ("0x%llx: Acquiring HELLO of peer %s\n",
1200  (unsigned long long) occ->op_id,
1201  GNUNET_i2s (&occ->peer_identity));
1202  /* Lookup for HELLO in hello cache */
1203  if (NULL != (hello = GST_cache_lookup_hello (occ->peer->id)))
1204  {
1205  LOG_DEBUG ("0x%llx: HELLO of peer %s found in cache\n",
1206  (unsigned long long) occ->op_id,
1207  GNUNET_i2s (&occ->peer_identity));
1208  occ->hello = GNUNET_copy_message (hello);
1209  p2_transport_connect (occ);
1210  return;
1211  }
1212  GNUNET_asprintf (&occ->emsg,
1213  "0x%llx: Timeout while acquiring TRANSPORT of %s from cache",
1214  (unsigned long long) occ->op_id,
1215  GNUNET_i2s (&occ->peer_identity));
1216  occ->cgh_p1th =
1218  occ->peer->details.local.cfg,
1221  occ,
1222  NULL, NULL, NULL);
1223 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static struct GNUNET_PeerIdentity my_identity
Identity of this 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 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_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
Header for all communications.

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

Referenced by handle_overlay_connect(), and overlay_connect_get_config().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ overlay_connect_get_config()

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

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

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

Parameters
clsForwardedOperationContext
msgthe peer create success message

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

1237 {
1238  struct OverlayConnectContext *occ = cls;
1239  struct RemotePeer2Context *rp2c;
1241 
1242  GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1243  rp2c = &occ->p2ctx.remote;
1244  rp2c->opc = NULL;
1245  GNUNET_assert (NULL != occ->timeout_task);
1247  {
1249  occ->timeout_task =
1251  }
1252  cmsg =
1254  occ->other_peer_identity = cmsg->peer_identity;
1255  GNUNET_free (occ->emsg);
1256  GNUNET_asprintf (&occ->emsg,
1257  "0x%llx: Timeout while connecting to CORE of peer with "
1258  "id: %u",
1259  (unsigned long long) occ->op_id,
1260  occ->peer->id);
1261  occ->cgh_ch =
1263  occ->peer->details.local.cfg,
1266  occ,
1267  &occ->other_peer_identity,
1269  occ);
1270 }
@ GST_CONNECTIONPOOL_SERVICE_CORE
Core service.
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.
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.
#define GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION
Message containing the peer's information.
Peer configuration and identity reply from controller to a client.
Definition: testbed.h:604
struct GNUNET_PeerIdentity peer_identity
Identity of the peer.
Definition: testbed.h:623
Context data for operations on second peer in remote overlay connection contexts.

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

Referenced by p2_controller_connect_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ host_registration_comp()

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

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

Parameters
clsthe RegisteredHostContext
emsgthe error message; NULL if host registration is successful

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

1281 {
1282  struct RegisteredHostContext *rhc = cls;
1283 
1284  rhc->state = RHC_DONE;
1285  GST_process_next_focc (rhc);
1286 }
@ RHC_DONE
State where we attempt to do the overlay connection again.

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

Referenced by register_host().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ reghost_match_iterator()

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

Iterator to match a registered host context.

Parameters
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 1300 of file gnunet-service-testbed_oc.c.

1303 {
1304  struct RegisteredHostContext **rh = cls;
1305  struct RegisteredHostContext *rh_val = value;
1306 
1307  if ((rh_val->host == (*rh)->host) && (rh_val->reg_host == (*rh)->reg_host))
1308  {
1309  GNUNET_free (*rh);
1310  *rh = rh_val;
1311  return GNUNET_NO;
1312  }
1313  return GNUNET_YES;
1314 }
static char * value
Value of the record to add/remove.
struct GNUNET_TESTBED_Host * host
The host of the controller which has to connect to the above rhost.
struct GNUNET_TESTBED_Host * reg_host
The host which is being registered.

Referenced by register_host().

Here is the caller graph for this function:

◆ hash_hosts()

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

Function to generate the hashcode corresponding to a RegisteredHostContext.

Parameters
reg_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 1300 of file gnunet-service-testbed_oc.c.

1327 {
1328  struct GNUNET_HashCode hash;
1329  uint32_t host_ids[2];
1330 
1331  host_ids[0] = GNUNET_TESTBED_host_get_id_ (reg_host);
1332  host_ids[1] = GNUNET_TESTBED_host_get_id_ (host);
1333  GNUNET_CRYPTO_hash (host_ids, sizeof(host_ids), &hash);
1334  return hash;
1335 }
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
A 512-bit hashcode.
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain the host's unique global ID.

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

Referenced by register_host().

Here is the caller graph for this function:

◆ register_host()

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

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

Parameters
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 1352 of file gnunet-service-testbed_oc.c.

1354 {
1355  struct GNUNET_HashCode hash;
1356  struct RegisteredHostContext *rhc;
1357 
1358  rhc = GNUNET_new (struct RegisteredHostContext);
1359  rhc->reg_host = host;
1360  rhc->host = GST_host_list[slave->host_id];
1361  GNUNET_assert (NULL != rhc->reg_host);
1362  GNUNET_assert (NULL != rhc->host);
1363  rhc->state = RHC_INIT;
1364  hash = hash_hosts (rhc->reg_host, rhc->host);
1365  if ((GNUNET_NO ==
1367  &hash)) ||
1368  (GNUNET_SYSERR !=
1370  &hash,
1372  &rhc)))
1373  {
1374  /* create and add a new registered host context */
1375  /* add the focc to its queue */
1377  &hash,
1378  rhc,
1382  rhc,
1383  rhc->reg_host);
1384  }
1385  else
1386  {
1387  /* rhc is now set to the existing one from the hash map by
1388  * reghost_match_iterator() */
1389  /* if queue is empty then ignore creating focc and proceed with normal
1390  * forwarding */
1391  if (RHC_DONE == rhc->state)
1392  return NULL;
1393  }
1394  return rhc;
1395 }
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
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.
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.
static int reghost_match_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to match a registered host context.
static void host_registration_comp(void *cls, const char *emsg)
Callback which will be called after a host registration succeeded or failed.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
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.
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).
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ RHC_INIT
The initial state.
uint32_t host_id
The id of the host this controller is running on.
struct GNUNET_CONTAINER_MultiHashMap * reghost_map
Hashmap to hold Registered host contexts.

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

Referenced by forward_overlay_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ forward_overlay_connect()

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

Forwards the overlay connect request to a slave controller.

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

Parameters
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 1408 of file gnunet-service-testbed_oc.c.

1410 {
1411  struct ForwardedOperationContext *fopc;
1412  struct Route *route_to_peer2_host;
1413  struct Route *route_to_peer1_host;
1414  struct Peer *peer;
1415  struct RegisteredHostContext *rhc;
1416  struct ForwardedOverlayConnectContext *focc;
1417  uint64_t op_id;
1418  uint32_t peer2_host_id;
1419  uint32_t p1;
1420  uint32_t p2;
1421 
1422  p1 = ntohl (msg->peer1);
1423  p2 = ntohl (msg->peer2);
1424  op_id = GNUNET_ntohll (msg->operation_id);
1425  peer2_host_id = ntohl (msg->peer2_host_id);
1428  peer = GST_peer_list[p1];
1429  GNUNET_assert (GNUNET_YES == peer->is_remote);
1430  LOG_DEBUG ("0x%llx: Forwarding overlay connect\n",
1431  (unsigned long long) op_id);
1432  route_to_peer2_host = GST_find_dest_route (peer2_host_id);
1433  route_to_peer1_host = GST_find_dest_route
1434  (peer->details.remote.remote_host_id);
1435  GNUNET_assert (NULL != route_to_peer1_host);
1436  if ((NULL != route_to_peer2_host) &&
1437  (route_to_peer1_host->dest == route_to_peer2_host->dest))
1438  goto forward;
1439  /* Peer2 is either with us OR peer1 and peer2 can be reached through
1440  different subtrees OR peer2 is on a subtree unknown to us */
1441  if (NULL != (rhc = register_host (peer->details.remote.slave,
1443  {
1444  LOG_DEBUG ("Queueing forwarding FOCC for connecting peers %u and %u\n", p1,
1445  p2);
1447  focc->rhc = rhc;
1448  focc->peer1 = p1;
1449  focc->peer2 = p2;
1450  focc->peer2_host_id = peer2_host_id;
1451  focc->orig_msg = GNUNET_copy_message (&msg->header);
1452  focc->operation_id = op_id;
1453  focc->client = client;
1455  rhc->focc_dll_tail,
1456  focc);
1457  return;
1458  }
1459 
1460 forward:
1461  LOG_DEBUG ("Forwarding without FOCC for connecting peers %u and %u\n", p1,
1462  p2);
1463  fopc = GNUNET_new (struct ForwardedOperationContext);
1464  fopc->client = client;
1465  fopc->operation_id = op_id;
1466  fopc->type = OP_OVERLAY_CONNECT;
1467  fopc->opc =
1469  slave->controller, op_id,
1470  &msg->header,
1472  fopc);
1473  fopc->timeout_task =
1476  fopc);
1478  fopcq_tail,
1479  fopc);
1480 }
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...
#define VALID_HOST_ID(id)
Condition to check if host id is valid.
static struct RegisteredHostContext * register_host(struct Slave *slave, struct GNUNET_TESTBED_Host *host)
Checks if the given host is registered at the given slave.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
uint32_t peer2_host_id
Id of the host where peer2 is running.
struct GNUNET_TESTBED_Controller * controller
Our controller context (not necessarily the controller that is responsible for starting/running the p...
A routing entry.
uint32_t dest
destination host

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

Referenced by handle_overlay_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ p2_controller_connect_cb()

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

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

Parameters
clsthe overlay connect contexts
chandle to the controller connection

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

1493 {
1494  struct OverlayConnectContext *occ = cls;
1495  struct RemotePeer2Context *rp2c;
1497 
1498  GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1499  rp2c = &occ->p2ctx.remote;
1500  rp2c->ncn = NULL;
1501  rp2c->p2c = c;
1502  cmsg.header.size =
1503  htons (sizeof(struct GNUNET_TESTBED_PeerGetConfigurationMessage));
1504  cmsg.header.type =
1506  cmsg.peer_id = htonl (occ->other_peer_id);
1507  cmsg.operation_id = GNUNET_htonll (occ->op_id);
1508  rp2c->opc =
1510  occ->op_id,
1511  &cmsg.header,
1513  occ);
1514  GNUNET_free (occ->emsg);
1515  GNUNET_asprintf (&occ->emsg,
1516  "0x%llx: Timeout while getting peer identity of peer "
1517  "with id: %u",
1518  (unsigned long long) occ->op_id,
1519  occ->other_peer_id);
1520 }
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...
#define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION
Message to get a peer's information.
Message sent from client to testing service to obtain the configuration of a peer.
Definition: testbed.h:582

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

Referenced by handle_overlay_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_overlay_connect()

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

Handler for GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages.

Parameters
clsidentification of the client
msgthe actual message

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

1532 {
1533  struct GNUNET_SERVICE_Client *client = cls;
1534  struct Peer *peer;
1535  struct Peer *peer2;
1536  struct OverlayConnectContext *occ;
1537  struct Neighbour *p2n;
1538  uint64_t operation_id;
1539  uint32_t p1;
1540  uint32_t p2;
1541  uint32_t peer2_host_id;
1542 
1543  p1 = ntohl (msg->peer1);
1544  p2 = ntohl (msg->peer2);
1545  if (p1 == p2)
1546  {
1547  GNUNET_break (0);
1548  GNUNET_SERVICE_client_drop (client);
1549  return;
1550  }
1551  if (! VALID_PEER_ID (p1))
1552  {
1553  GNUNET_break (0);
1554  GNUNET_SERVICE_client_drop (client);
1555  return;
1556  }
1557  peer = GST_peer_list[p1];
1558  operation_id = GNUNET_ntohll (msg->operation_id);
1559  LOG_DEBUG
1560  ("Received overlay connect for peers %u and %u with op id: 0x%llx\n",
1561  p1,
1562  p2,
1563  (unsigned long long) operation_id);
1564  peer2_host_id = ntohl (msg->peer2_host_id);
1565  if (GNUNET_YES == peer->is_remote)
1566  {
1567  if (! VALID_HOST_ID (peer2_host_id))
1568  {
1569  GNUNET_break (0);
1570  GNUNET_SERVICE_client_drop (client);
1571  return;
1572  }
1573  forward_overlay_connect (msg, client);
1575  return;
1576  }
1577  p2n = NULL;
1578  occ = GNUNET_new (struct OverlayConnectContext);
1579  occ->type = OCC_TYPE_LOCAL;
1580  if (! VALID_PEER_ID (p2)) /* May be peer2 is on a another controller */
1581  {
1582  if (NULL == (p2n = GST_get_neighbour (peer2_host_id)))
1583  {
1584  if (! VALID_HOST_ID (peer2_host_id))
1585  {
1586  GNUNET_break (0);
1588  "0x%llx: Peer %u's host not in our neighbours list\n",
1589  (unsigned long long) operation_id, p2);
1590  GNUNET_SERVICE_client_drop (client);
1591  GNUNET_free (occ);
1592  return;
1593  }
1594  p2n = GST_create_neighbour (GST_host_list[peer2_host_id]);
1595  }
1597  occ->p2ctx.remote.p2n = p2n;
1598  }
1599  else if (GNUNET_YES == GST_peer_list[p2]->is_remote)
1600  {
1601  occ->type = OCC_TYPE_REMOTE_SLAVE;
1602  occ->p2ctx.remote.p2c = GST_peer_list[p2]->details.remote.slave->controller;
1603  }
1605  occq_tail,
1606  occ);
1607  occ->client = client;
1608  occ->other_peer_id = p2;
1610  occ->peer = GST_peer_list[p1];
1611  occ->op_id = operation_id;
1612  GNUNET_assert (NULL == occ->timeout_task);
1613  occ->timeout_task =
1616  occ);
1617  switch (occ->type)
1618  {
1620  GNUNET_asprintf (&occ->emsg,
1621  "0x%llx: Timeout while acquiring connection to peer %u's "
1622  "host: %u\n",
1623  (unsigned long long) occ->op_id,
1624  occ->other_peer_id,
1625  peer2_host_id);
1626  occ->p2ctx.remote.ncn
1629  occ);
1630  break;
1631  case OCC_TYPE_REMOTE_SLAVE:
1633  occ->p2ctx.remote.p2c);
1634  break;
1635  case OCC_TYPE_LOCAL:
1636  peer2 = GST_peer_list[occ->other_peer_id];
1637  peer2->reference_cnt++;
1639  &occ->other_peer_identity);
1640  GNUNET_asprintf (&occ->emsg,
1641  "0x%llx: Timeout while connecting to CORE of peer with "
1642  "id: %u",
1643  (unsigned long long) occ->op_id,
1644  occ->peer->id);
1645  LOG_DEBUG ("Peer %u has PID %s\n",
1646  occ->other_peer_id,
1648  {
1649  struct GNUNET_PeerIdentity lpid;
1650 
1651  GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
1652  &lpid);
1653  LOG_DEBUG ("Peer %u has PID %s\n",
1654  p1,
1655  GNUNET_i2s (&lpid));
1656  }
1657  occ->cgh_ch =
1659  occ->peer->details.local.cfg,
1662  &occ->other_peer_identity,
1663  &overlay_connect_notify, occ);
1664  break;
1665  }
1667 }
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.
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.
#define LOG(kind,...)
Redefine LOG with a changed log component string.
@ GNUNET_ERROR_TYPE_WARNING
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2329
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2248
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:1341
The identity of the host (wraps the signing key of the peer).
Handle to a client that is connected to a service.
Definition: service.c:251
A connected controller which is not our child.
struct Peer::@57::@59 remote

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

Here is the call graph for this function:

◆ cleanup_rocc()

static void cleanup_rocc ( struct RemoteOverlayConnectCtx rocc)
static

Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.

Parameters
roccthe RemoteOverlayConnectCtx

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

1678 {
1679  LOG_DEBUG ("0x%llx: Cleaning up rocc\n",
1680  (unsigned long long) rocc->op_id);
1681  if (NULL != rocc->attempt_connect_task_id)
1683  if (NULL != rocc->timeout_rocc_task_id)
1685  if (NULL != rocc->ohh)
1687  if (NULL != rocc->tcc.csh)
1691  GNUNET_assert (rocc->peer->reference_cnt > 0);
1692  rocc->peer->reference_cnt--;
1693  if ((GNUNET_YES == rocc->peer->destroy_flag) &&
1694  (0 == rocc->peer->reference_cnt))
1695  GST_destroy_peer (rocc->peer);
1696  GNUNET_free (rocc->hello);
1698  roccq_tail,
1699  rocc);
1700  GNUNET_free (rocc);
1701 }
static struct RemoteOverlayConnectCtx * roccq_tail
DLL tail for RequectOverlayConnectContext 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,...
struct GNUNET_SCHEDULER_Task * attempt_connect_task_id
Task for offering HELLO of A to B and doing try_connect.
struct GNUNET_TRANSPORT_OfferHelloHandle * ohh
The handle for offering HELLO.
struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id
Task to timeout RequestOverlayConnect.
struct Peer * peer
The peer handle of peer B.
uint64_t op_id
The id of the operation responsible for creating this context.
struct GNUNET_MessageHeader * hello
Peer A's HELLO.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ timeout_rocc_task()

static void timeout_rocc_task ( void *  cls)
static

Task to timeout rocc and cleanit up.

Parameters
clsthe RemoteOverlayConnectCtx

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

1711 {
1712  struct RemoteOverlayConnectCtx *rocc = cls;
1713 
1714  GNUNET_assert (rocc->timeout_rocc_task_id != NULL);
1715  rocc->timeout_rocc_task_id = NULL;
1716  LOG_DEBUG ("0x%llx: rocc timed out\n",
1717  (unsigned long long) rocc->op_id);
1718  cleanup_rocc (rocc);
1719 }
static void cleanup_rocc(struct RemoteOverlayConnectCtx *rocc)
Function to cleanup RemoteOverlayConnectCtx and any associated tasks with it.

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

Referenced by handle_remote_overlay_connect(), and rocc_cache_get_handle_transport_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cache_transport_peer_connect_notify()

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

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

Parameters
clsthe RemoteOverlayConnectContext
new_peerthe peer that connected

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

1732 {
1733  struct RemoteOverlayConnectCtx *rocc = cls;
1734 
1735  LOG_DEBUG ("0x%llx: Request Overlay connect notify\n",
1736  (unsigned long long) rocc->op_id);
1737  GNUNET_assert (0 ==
1738  memcmp (new_peer, &rocc->a_id,
1739  sizeof(struct GNUNET_PeerIdentity)));
1740  LOG_DEBUG ("0x%llx: Peer %s connected\n",
1741  (unsigned long long) rocc->op_id,
1742  GNUNET_i2s (&rocc->a_id));
1743  cleanup_rocc (rocc);
1744 }

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

Referenced by handle_remote_overlay_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ attempt_connect_task()

static void attempt_connect_task ( void *  cls)
static

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

Parameters
clsthe RemoteOverlayConnectCtx

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

1792 {
1793  struct RemoteOverlayConnectCtx *rocc = cls;
1794 
1795  GNUNET_assert (NULL != rocc->attempt_connect_task_id);
1796  rocc->attempt_connect_task_id = NULL;
1797  LOG_DEBUG ("0x%llx: Offering HELLO of peer %s to remote peer with id: %u\n",
1798  (unsigned long long) rocc->op_id,
1799  GNUNET_i2s (&rocc->a_id),
1800  rocc->peer->id);
1801  rocc->ohh =
1803  rocc->hello,
1805  rocc);
1806  if (NULL == rocc->ohh)
1807  rocc->attempt_connect_task_id =
1810  100
1813  &attempt_connect_task, rocc);
1814 }
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...
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...

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

Referenced by rocc_cache_get_handle_transport_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rocc_hello_sent_cb()

static void rocc_hello_sent_cb ( void *  cls)
static

Task that is run when hello has been sent If tc->reason = GNUNET_SCHEDULER_REASON_TIMEOUT then sending HELLO failed; if GNUNET_SCHEDULER_REASON_READ_READY is succeeded.

Parameters
clsthe overlay connect context

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

1766 {
1767  struct RemoteOverlayConnectCtx *rocc = cls;
1768 
1769  rocc->ohh = NULL;
1770  GNUNET_assert (NULL == rocc->attempt_connect_task_id);
1771  LOG_DEBUG ("0x%llx: HELLO of peer %s delivered to local peer with id: %u\n",
1772  (unsigned long long) rocc->op_id,
1773  GNUNET_i2s (&rocc->a_id),
1774  rocc->peer->id);
1775  rocc->tcc.cgh_p2_ats =
1777  rocc->peer->details.local.cfg,
1780  rocc, NULL, NULL, NULL);
1781 }
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.

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

Referenced by attempt_connect_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rocc_cache_get_handle_transport_cb()

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

Callback from cache with needed handles set.

Parameters
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 1827 of file gnunet-service-testbed_oc.c.

1834 {
1835  struct RemoteOverlayConnectCtx *rocc = cls;
1836 
1837  if (NULL == th)
1838  {
1839  rocc->timeout_rocc_task_id =
1841  return;
1842  }
1843  rocc->tcc.th_ = th;
1844  rocc->tcc.cfg = cfg;
1845  if (NULL !=
1847  &rocc->a_id))
1848  {
1849  LOG_DEBUG ("0x%llx: Target peer %s already connected to local peer: %u\n",
1850  (unsigned long long) rocc->op_id,
1851  GNUNET_i2s (&rocc->a_id),
1852  rocc->peer->id);
1853  cleanup_rocc (rocc);
1854  return;
1855  }
1856  rocc->attempt_connect_task_id =
1858 }
static void timeout_rocc_task(void *cls)
Task to timeout rocc and cleanit up.
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.

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

Referenced by handle_remote_overlay_connect().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_remote_overlay_connect()

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

Check GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.

Parameters
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

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

1872 {
1873  uint32_t peer_id;
1874  uint16_t msize;
1875  uint16_t hsize;
1876 
1877  msize = ntohs (msg->header.size);
1878  if (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type))
1879  {
1880  GNUNET_break (0);
1881  return GNUNET_SYSERR;
1882  }
1883  hsize = ntohs (msg->hello->size);
1884  if ((sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) !=
1885  msize)
1886  {
1887  GNUNET_break (0);
1888  return GNUNET_SYSERR;
1889  }
1890  peer_id = ntohl (msg->peer);
1891  if ((peer_id >= GST_peer_list_size) ||
1892  (NULL == GST_peer_list[peer_id]))
1893  {
1894  GNUNET_break_op (0);
1895  return GNUNET_SYSERR;
1896  }
1897  return GNUNET_OK;
1898 }
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
unsigned int GST_peer_list_size
The size of the peer list.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_MESSAGE_TYPE_HELLO
HELLO message with friend only flag used for communicating peer addresses.

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

◆ handle_remote_overlay_connect()

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

Handler for GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.

Parameters
clsidentification of the client
msgthe actual message

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

1911 {
1912  struct GNUNET_SERVICE_Client *client = cls;
1913  struct RemoteOverlayConnectCtx *rocc;
1914  struct Peer *peer;
1915  struct GNUNET_PeerIdentity pid;
1916  static char pid_str[16];
1917  uint32_t peer_id;
1918  uint16_t hsize;
1919 
1920  hsize = ntohs (msg->hello->size);
1921  peer_id = ntohl (msg->peer);
1923  if (GNUNET_YES == peer->is_remote)
1924  {
1925  struct GNUNET_MessageHeader *msg2;
1926 
1927  msg2 = GNUNET_copy_message (&msg->header);
1928  GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller,
1929  msg2);
1931  return;
1932  }
1933  rocc = GNUNET_new (struct RemoteOverlayConnectCtx);
1934  rocc->op_id = GNUNET_ntohll (msg->operation_id);
1936  roccq_tail,
1937  rocc);
1938  rocc->a_id = msg->peer_identity;
1939  GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
1940  &pid);
1941  (void) GNUNET_strlcpy (pid_str,
1942  GNUNET_i2s (&pid),
1943  sizeof(pid_str));
1944  LOG_DEBUG (
1945  "0x%llx: Remote overlay connect %s to peer %s with hello size: %u\n",
1946  (unsigned long long) rocc->op_id,
1947  pid_str,
1948  GNUNET_i2s (&rocc->a_id),
1949  hsize);
1950  rocc->peer = peer;
1951  rocc->peer->reference_cnt++;
1952  rocc->hello = GNUNET_malloc (hsize);
1953  GNUNET_memcpy (rocc->hello,
1954  msg->hello,
1955  hsize);
1956  rocc->tcc.cgh_p2_th =
1958  rocc->peer->details.local.cfg,
1961  rocc,
1962  &rocc->a_id,
1964  rocc);
1965  rocc->timeout_rocc_task_id =
1968  rocc);
1970 }
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.
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 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:139

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

Here is the call graph for this function:

◆ GST_free_occq()

void GST_free_occq ( void  )

Clears all pending overlay connect contexts in queue.

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

1978 {
1979  struct OverlayConnectContext *occ;
1980 
1981  while (NULL != (occ = occq_head))
1982  cleanup_occ (occ);
1983 }

References cleanup_occ(), and occq_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GST_free_roccq()

void GST_free_roccq ( void  )

Clears all pending remote overlay connect contexts in queue.

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

1991 {
1992  struct RemoteOverlayConnectCtx *rocc;
1993 
1994  while (NULL != (rocc = roccq_head))
1995  cleanup_rocc (rocc);
1996 }

References cleanup_rocc(), and roccq_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ occq_head

struct OverlayConnectContext* occq_head
static

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

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

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

◆ occq_tail

struct OverlayConnectContext* occq_tail
static

DLL tail for OverlayConnectContext DLL.

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

Referenced by cleanup_occ(), and handle_overlay_connect().

◆ roccq_head

struct RemoteOverlayConnectCtx* roccq_head
static

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

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

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

◆ roccq_tail

struct RemoteOverlayConnectCtx* roccq_tail
static

DLL tail for RequectOverlayConnectContext DLL.

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

Referenced by cleanup_rocc(), and handle_remote_overlay_connect().