GNUnet  0.20.0
transport-testing2.h File Reference
Include dependency graph for transport-testing2.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  GNUNET_TRANSPORT_TESTING_PeerContext
 Context for a single peer. More...
 
struct  GNUNET_TRANSPORT_TESTING_ConnectRequest
 Handle for a request to connect two peers. More...
 
struct  GNUNET_TRANSPORT_TESTING_Handle
 Handle for a test run. More...
 
struct  GNUNET_TRANSPORT_TESTING_TestMessage
 
struct  GNUNET_TRANSPORT_TESTING_PerformanceTestMessage
 
struct  GNUNET_TRANSPORT_TESTING_ConnectCheckContext
 Closure that must be passed to GNUNET_TRANSPORT_TESTING_connect_check. More...
 
struct  GNUNET_TRANSPORT_TESTING_SendClosure
 Type of the closure argument to pass to GNUNET_TRANSPORT_TESTING_simple_send() and GNUNET_TRANSPORT_TESTING_large_send(). More...
 

Macros

#define GNUNET_TRANSPORT_TESTING_main(num_peers, check, check_cls)
 Setup testcase. More...
 
#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE   12345
 Message type used by GNUNET_TRANSPORT_TESTING_simple_send(). More...
 
#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2   12346
 Alternative message type for tests. More...
 
#define GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE   12347
 Message type used by #(). More...
 
#define GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE   2600
 Size of a message sent with GNUNET_TRANSPORT_TESTING_large_send(). More...
 

Typedefs

typedef void(* GNUNET_TRANSPORT_TESTING_ConnectContextCallback) (void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
 Function called on matching connect requests. More...
 
typedef void(* GNUNET_TRANSPORT_TESTING_ConnectContinuation) (void *cls, unsigned int num_peers, struct GNUNET_TRANSPORT_TESTING_PeerContext *p[])
 Function called once the peers have been launched and connected by GNUNET_TRANSPORT_TESTING_connect_check(). More...
 
typedef void(* GNUNET_TRANSPORT_TESTING_NotifyConnect) (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
 Function called to notify transport users that another peer connected to us. More...
 
typedef void(* GNUNET_TRANSPORT_TESTING_NotifyDisconnect) (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
 Function called to notify transport users that another peer disconnected from us. More...
 
typedef int(* GNUNET_TRANSPORT_TESTING_CheckCallback) (void *cls, struct GNUNET_TRANSPORT_TESTING_Handle *tth_, const char *test_plugin_, const char *test_name_, unsigned int num_peers, char *cfg_files[])
 Main function of a testcase. More...
 

Functions

struct GNUNET_TRANSPORT_TESTING_HandleGNUNET_TRANSPORT_TESTING_init (void)
 Initialize the transport testing. More...
 
void GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth)
 Clean up the transport testing. More...
 
struct GNUNET_TRANSPORT_TESTING_PeerContextGNUNET_TRANSPORT_TESTING_start_peer (struct GNUNET_TRANSPORT_TESTING_Handle *tth, const char *cfgname, int peer_id, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd, void *cb_cls, GNUNET_SCHEDULER_TaskCallback start_cb, void *start_cb_cls)
 Start a peer with the given configuration. More...
 
void GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_PeerContext *pc)
 Shutdown the given peer. More...
 
int GNUNET_TRANSPORT_TESTING_restart_peer (struct GNUNET_TRANSPORT_TESTING_PeerContext *p, GNUNET_SCHEDULER_TaskCallback restart_cb, void *restart_cb_cls)
 Stops and restarts the given peer, sleeping (!) for 5s in between. More...
 
struct GNUNET_TRANSPORT_TESTING_ConnectRequestGNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_PeerContext *p1, struct GNUNET_TRANSPORT_TESTING_PeerContext *p2, GNUNET_SCHEDULER_TaskCallback cb, void *cls)
 Connect the given peers and call the callback when both peers report the inbound connection. More...
 
void GNUNET_TRANSPORT_TESTING_connect_peers_cancel (struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
 Cancel the request to connect two peers. More...
 
void GNUNET_TRANSPORT_TESTING_find_connecting_context (struct GNUNET_TRANSPORT_TESTING_PeerContext *p1, struct GNUNET_TRANSPORT_TESTING_PeerContext *p2, GNUNET_TRANSPORT_TESTING_ConnectContextCallback cb, void *cb_cls)
 Find any connecting context matching the given pair of peers. More...
 
struct GNUNET_TRANSPORT_TESTING_PeerContextGNUNET_TRANSPORT_TESTING_find_peer (struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc, const struct GNUNET_PeerIdentity *peer)
 Find peer by peer ID. More...
 
int GNUNET_TRANSPORT_TESTING_connect_check (void *cls, struct GNUNET_TRANSPORT_TESTING_Handle *tth_, const char *test_plugin_, const char *test_name_, unsigned int num_peers, char *cfg_files[])
 Common implementation of the GNUNET_TRANSPORT_TESTING_CheckCallback. More...
 
int GNUNET_TRANSPORT_TESTING_main_ (const char *argv0, const char *filename, unsigned int num_peers, GNUNET_TRANSPORT_TESTING_CheckCallback check, void *check_cls)
 Setup testcase. More...
 
int GNUNET_TRANSPORT_TESTING_send (struct GNUNET_TRANSPORT_TESTING_PeerContext *sender, struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, uint16_t mtype, uint16_t msize, uint32_t num, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
 Send a test message of type mtype and size msize from peer sender to peer receiver. More...
 
void GNUNET_TRANSPORT_TESTING_simple_send (void *cls)
 Task that sends a minimalistic test message from the first peer to the second peer. More...
 
void GNUNET_TRANSPORT_TESTING_large_send (void *cls)
 Task that sends a large test message from the first peer to the second peer. More...
 
void GNUNET_TRANSPORT_TESTING_log_connect (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
 Log a connect event. More...
 
void GNUNET_TRANSPORT_TESTING_log_disconnect (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
 Log a disconnect event. More...
 
char * GNUNET_TRANSPORT_TESTING_get_test_name (const char *file)
 Extracts the test filename from an absolute file name and removes the extension. More...
 
char * GNUNET_TRANSPORT_TESTING_get_config_name (const char *file, int count)
 This function takes the filename (e.g. More...
 
char * GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *executable, const char *testname)
 Extracts the plugin anme from an absolute file name and the test name. More...
 
char * GNUNET_TRANSPORT_TESTING_get_test_source_name (const char *file)
 Extracts the filename from an absolute file name and removes the extension. More...
 

Variables

GNUNET_NETWORK_STRUCT_END typedef void(* GNUNET_TRANSPORT_TESTING_ReceiveCallback )(void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
 Function called by the transport for each received message. More...
 

Macro Definition Documentation

◆ GNUNET_TRANSPORT_TESTING_main

#define GNUNET_TRANSPORT_TESTING_main (   num_peers,
  check,
  check_cls 
)
Value:
__FILE__, \
check, \
check_cls)
static unsigned int num_peers
int GNUNET_TRANSPORT_TESTING_main_(const char *argv0, const char *filename, unsigned int num_peers, GNUNET_TRANSPORT_TESTING_CheckCallback check, void *check_cls)
Setup testcase.

Setup testcase.

Calls check with the data the test needs.

Parameters
num_peersnumber of peers to start
checkmain function to run
check_clsclosure for check
Returns
GNUNET_OK on success

Definition at line 749 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE

#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE   12345

Message type used by GNUNET_TRANSPORT_TESTING_simple_send().

Definition at line 789 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2

#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2   12346

Alternative message type for tests.

Definition at line 794 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE

#define GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE   12347

Message type used by #().

Definition at line 799 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE

#define GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE   2600

Size of a message sent with GNUNET_TRANSPORT_TESTING_large_send().

Big enough to usually force defragmentation.

Definition at line 854 of file transport-testing2.h.

Typedef Documentation

◆ GNUNET_TRANSPORT_TESTING_ConnectContextCallback

typedef void(* GNUNET_TRANSPORT_TESTING_ConnectContextCallback) (void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)

Function called on matching connect requests.

Parameters
clsclosure
ccrequest matching the query

Definition at line 376 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_ConnectContinuation

typedef void(* GNUNET_TRANSPORT_TESTING_ConnectContinuation) (void *cls, unsigned int num_peers, struct GNUNET_TRANSPORT_TESTING_PeerContext *p[])

Function called once the peers have been launched and connected by GNUNET_TRANSPORT_TESTING_connect_check().

Parameters
clsclosure
num_peerssize of the p array
pthe peers that were launched

Definition at line 408 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_NotifyConnect

typedef void(* GNUNET_TRANSPORT_TESTING_NotifyConnect) (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)

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

Parameters
clsclosure
mepeer experiencing the event
otherpeer that connected to me

Definition at line 483 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_NotifyDisconnect

typedef void(* GNUNET_TRANSPORT_TESTING_NotifyDisconnect) (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)

Function called to notify transport users that another peer disconnected from us.

Parameters
clsclosure
mepeer experiencing the event
otherpeer that disconnected from me

Definition at line 497 of file transport-testing2.h.

◆ GNUNET_TRANSPORT_TESTING_CheckCallback

typedef int(* GNUNET_TRANSPORT_TESTING_CheckCallback) (void *cls, struct GNUNET_TRANSPORT_TESTING_Handle *tth_, const char *test_plugin_, const char *test_name_, unsigned int num_peers, char *cfg_files[])

Main function of a testcase.

Called with the initial setup data for the test as derived from the source name and the binary name.

Parameters
clsclosure
tth_initialized testing handle
test_plugin_name of the plugin
test_name_name of the test
num_peersnumber of entries in the cfg_file array
cfg_filesarray of names of configuration files for the peers
Returns
GNUNET_SYSERR on error

Definition at line 714 of file transport-testing2.h.

Function Documentation

◆ GNUNET_TRANSPORT_TESTING_init()

struct GNUNET_TRANSPORT_TESTING_Handle* GNUNET_TRANSPORT_TESTING_init ( )

Initialize the transport testing.

Returns
transport testing handle

Definition at line 912 of file transport-testing.c.

913 {
915 
917  tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
918  NULL,
919  NULL,
920  NULL);
921  if (NULL == tth->tl_system)
922  {
924  "Failed to initialize testing library!\n");
925  GNUNET_free (tth);
926  return NULL;
927  }
928  return tth;
929 }
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_TESTING_System * GNUNET_TESTING_system_create(const char *testdir, const char *trusted_ip, const char *hostname, const struct GNUNET_TESTING_SharedService *shared_services)
Create a system handle.
Definition: testing.c:477
struct GNUNET_TESTING_System * tl_system
Testing library system handle.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_TESTING_system_create(), and GNUNET_TRANSPORT_TESTING_Handle::tl_system.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

◆ GNUNET_TRANSPORT_TESTING_done()

void GNUNET_TRANSPORT_TESTING_done ( struct GNUNET_TRANSPORT_TESTING_Handle tth)

Clean up the transport testing.

Parameters
tthtransport testing handle

Definition at line 872 of file transport-testing.c.

873 {
878 
879  if (NULL == tth)
880  return;
881  cc = tth->cc_head;
882  while (NULL != cc)
883  {
884  ct = cc->next;
886  "Developer forgot to cancel connect request!\n");
888  cc = ct;
889  }
890  p = tth->p_head;
891  while (NULL != p)
892  {
893  t = p->next;
895  "Developer forgot to stop peer!\n");
897  p = t;
898  }
900  GNUNET_YES);
901 
902  GNUNET_free (tth);
903 }
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static struct GNUNET_SCHEDULER_Task * t
Main task.
@ GNUNET_YES
void GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, int remove_paths)
Free system resources.
Definition: testing.c:557
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
void GNUNET_TRANSPORT_TESTING_stop_peer(struct GNUNET_TRANSPORT_TESTING_PeerContext *p)
Shutdown the given peer.
#define LOG(kind,...)
void GNUNET_TRANSPORT_TESTING_connect_peers_cancel(struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
Cancel the request to connect two peers Tou MUST cancel the request if you stop the peers before the ...

References GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_TESTING_system_destroy(), GNUNET_TRANSPORT_TESTING_connect_peers_cancel(), GNUNET_TRANSPORT_TESTING_stop_peer(), GNUNET_YES, LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, p, GNUNET_TRANSPORT_TESTING_Handle::p_head, t, GNUNET_TRANSPORT_TESTING_Handle::tl_system, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

◆ GNUNET_TRANSPORT_TESTING_start_peer()

struct GNUNET_TRANSPORT_TESTING_PeerContext* GNUNET_TRANSPORT_TESTING_start_peer ( struct GNUNET_TRANSPORT_TESTING_Handle tth,
const char *  cfgname,
int  peer_id,
const struct GNUNET_MQ_MessageHandler handlers,
GNUNET_TRANSPORT_NotifyConnect  nc,
GNUNET_TRANSPORT_NotifyDisconnect  nd,
void *  cb_cls,
GNUNET_SCHEDULER_TaskCallback  start_cb,
void *  start_cb_cls 
)

Start a peer with the given configuration.

Parameters
tththe testing handle
cfgnameconfiguration file
peer_idan identification number for the peer
handlersfunctions for receiving messages
ncconnect callback
nddisconnect callback
cb_clsclosure for nc and nd callback
start_cbstart callback
start_cb_clsclosure for start_cb
Returns
the peer context
Parameters
tththe testing handle
cfgnameconfiguration file
peer_ida unique number to identify the peer
handlersfunctions for receiving messages
ncconnect callback
nddisconnect callback
cb_clsclosure for callback
start_cbstart callback
start_cb_clsclosure for callback
Returns
the peer context
Parameters
tththe testing handle
cfgnameconfiguration file
peer_idthe peer_id
handlersfunctions for receiving messages
ncconnect callback
nddisconnect callback
cb_clsclosure for nc and nd callback
start_cbstart callback
start_cb_clsclosure for start_cb
Returns
the peer context
Parameters
tththe testing handle
cfgnameconfiguration file
peer_ida unique number to identify the peer
handlersfunctions for receiving messages
ncconnect callback
nddisconnect callback
cb_clsclosure for callback
start_cbstart callback
start_cb_clsclosure for callback
Returns
the peer context

Definition at line 382 of file transport-testing.c.

393 {
394  char *emsg = NULL;
396  struct GNUNET_PeerIdentity dummy;
397  unsigned int i;
398 
399  if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
400  {
402  "File not found: `%s'\n",
403  cfgname);
404  return NULL;
405  }
406 
408  p->tth = tth;
409  p->nc = nc;
410  p->nd = nd;
411  if (NULL != handlers)
412  {
413  for (i = 0; NULL != handlers[i].cb; i++)
414  ;
415  p->handlers = GNUNET_new_array (i + 1,
416  struct GNUNET_MQ_MessageHandler);
417  GNUNET_memcpy (p->handlers,
418  handlers,
419  i * sizeof(struct GNUNET_MQ_MessageHandler));
420  }
421  if (NULL != cb_cls)
422  p->cb_cls = cb_cls;
423  else
424  p->cb_cls = p;
425  p->start_cb = start_cb;
426  if (NULL != start_cb_cls)
427  p->start_cb_cls = start_cb_cls;
428  else
429  p->start_cb_cls = p;
431  tth->p_tail,
432  p);
433 
434  /* Create configuration and call testing lib to modify it */
435  p->cfg = GNUNET_CONFIGURATION_create ();
437  GNUNET_CONFIGURATION_load (p->cfg, cfgname));
438  if (GNUNET_SYSERR ==
440  p->cfg))
441  {
443  "Testing library failed to create unique configuration based on `%s'\n",
444  cfgname);
446  GNUNET_free (p);
447  return NULL;
448  }
449 
450  p->no = peer_id;
451  /* Configure peer with configuration */
453  p->cfg,
454  p->no,
455  NULL,
456  &emsg);
457  if (NULL == p->peer)
458  {
460  "Testing library failed to create unique configuration based on `%s': `%s'\n",
461  cfgname,
462  emsg);
464  GNUNET_free (emsg);
465  return NULL;
466  }
467 
468  if (GNUNET_OK != GNUNET_TESTING_peer_start (p->peer))
469  {
471  "Testing library failed to create unique configuration based on `%s'\n",
472  cfgname);
474  return NULL;
475  }
476 
477  memset (&dummy,
478  '\0',
479  sizeof(dummy));
481  &p->id);
482  if (0 == memcmp (&dummy,
483  &p->id,
484  sizeof(struct GNUNET_PeerIdentity)))
485  {
487  "Testing library failed to obtain peer identity for peer %u\n",
488  p->no);
490  return NULL;
491  }
493  "Peer %u configured with identity `%s'\n",
494  p->no,
495  GNUNET_i2s_full (&p->id));
497  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
498  NULL,
499  handlers,
500  p,
503  NULL);
504  if ((NULL == p->th) ||
505  (NULL == p->tmh))
506  {
508  "Failed to connect to transport service for peer `%s': `%s'\n",
509  cfgname,
510  emsg);
512  GNUNET_free (emsg);
513  return NULL;
514  }
515  p->ats = GNUNET_ATS_connectivity_init (p->cfg);
516  if (NULL == p->ats)
517  {
519  "Failed to connect to ATS service for peer `%s': `%s'\n",
520  cfgname,
521  emsg);
523  GNUNET_free (emsg);
524  return NULL;
525  }
526  p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
528  &get_hello,
529  p);
530  GNUNET_assert (NULL != p->ghh);
531  return p;
532 }
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
struct GNUNET_TRANSPORT_CoreHandle * GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *self, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_TRANSPORT_NotifyConnect nc, GNUNET_TRANSPORT_NotifyDisconnect nd)
Connect to the transport service.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
struct GNUNET_TESTING_Peer * GNUNET_TESTING_peer_configure(struct GNUNET_TESTING_System *system, struct GNUNET_CONFIGURATION_Handle *cfg, uint32_t key_number, struct GNUNET_PeerIdentity *id, char **emsg)
Configure a GNUnet peer.
Definition: testing.c:1188
int GNUNET_TESTING_peer_start(struct GNUNET_TESTING_Peer *peer)
Start the peer.
Definition: testing.c:1381
int GNUNET_TESTING_configuration_create(struct GNUNET_TESTING_System *system, struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new configuration using the given configuration as a template; ports and paths will be modif...
Definition: testing.c:1167
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:1359
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.
struct GNUNET_TRANSPORT_ManipulationHandle * GNUNET_TRANSPORT_manipulation_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the transport service.
@ GNUNET_TRANSPORT_AC_ANY
Bitmask for "any" address.
Message handler for a specific message type.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_tail
tail DLL of peers
static void start_cb(void *cls)
Function called once we have successfully launched a peer.
static void get_hello(void *cb_cls, const struct GNUNET_MessageHeader *message)
static void * notify_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
static void notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)

References dummy, get_hello(), GNUNET_assert, GNUNET_ATS_connectivity_init(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_load(), GNUNET_CONTAINER_DLL_insert, GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s_full(), GNUNET_memcpy, GNUNET_new, GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_connect(), GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, GNUNET_TESTING_configuration_create(), GNUNET_TESTING_peer_configure(), GNUNET_TESTING_peer_get_identity(), GNUNET_TESTING_peer_start(), GNUNET_TRANSPORT_AC_ANY, GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_core_connect(), GNUNET_TRANSPORT_hello_get(), GNUNET_TRANSPORT_manipulation_connect(), GNUNET_TRANSPORT_TESTING_stop_peer(), handlers, LOG, nc, notify_connect(), notify_disconnect(), p, GNUNET_TRANSPORT_TESTING_Handle::p_head, GNUNET_TRANSPORT_TESTING_Handle::p_tail, peer_id, retrieve_hello(), start_cb(), and GNUNET_TRANSPORT_TESTING_Handle::tl_system.

Referenced by connect_check_run().

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

◆ GNUNET_TRANSPORT_TESTING_stop_peer()

void GNUNET_TRANSPORT_TESTING_stop_peer ( struct GNUNET_TRANSPORT_TESTING_PeerContext p)

Shutdown the given peer.

Parameters
pthe peer

Definition at line 638 of file transport-testing.c.

640 {
641  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
644 
645  for (cc = tth->cc_head; NULL != cc; cc = ccn)
646  {
647  ccn = cc->next;
648  if ((cc->p1 == p) ||
649  (cc->p2 == p))
651  }
652  if (NULL != p->ghh)
653  {
655  p->ghh = NULL;
656  }
657  if (NULL != p->tmh)
658  {
660  p->tmh = NULL;
661  }
662  if (NULL != p->th)
663  {
665  p->th = NULL;
666  }
667  if (NULL != p->peer)
668  {
669  if (GNUNET_OK !=
670  GNUNET_TESTING_peer_stop (p->peer))
671  {
673  "Testing lib failed to stop peer %u (`%s')\n",
674  p->no,
675  GNUNET_i2s (&p->id));
676  }
678  p->peer = NULL;
679  }
680  if (NULL != p->ats)
681  {
683  p->ats = NULL;
684  }
685  if (NULL != p->hello)
686  {
687  GNUNET_free (p->hello);
688  p->hello = NULL;
689  }
690  if (NULL != p->cfg)
691  {
693  p->cfg = NULL;
694  }
695  if (NULL != p->handlers)
696  {
697  GNUNET_free (p->handlers);
698  p->handlers = NULL;
699  }
701  tth->p_tail,
702  p);
704  "Peer %u (`%s') stopped\n",
705  p->no,
706  GNUNET_i2s (&p->id));
707  GNUNET_free (p);
708 }
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int GNUNET_TESTING_peer_stop(struct GNUNET_TESTING_Peer *peer)
Stop the peer.
Definition: testing.c:1485
void GNUNET_TESTING_peer_destroy(struct GNUNET_TESTING_Peer *peer)
Destroy the peer.
Definition: testing.c:1566
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
void GNUNET_TRANSPORT_manipulation_disconnect(struct GNUNET_TRANSPORT_ManipulationHandle *handle)
Disconnect from the transport service.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.

References GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_ATS_connectivity_done(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_iterate_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_stop(), GNUNET_TRANSPORT_application_done(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_TRANSPORT_hello_get_cancel(), GNUNET_TRANSPORT_manipulation_disconnect(), GNUNET_TRANSPORT_TESTING_connect_peers_cancel(), LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, p, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, GNUNET_TRANSPORT_TESTING_Handle::p_head, and GNUNET_TRANSPORT_TESTING_Handle::p_tail.

Referenced by do_shutdown(), GNUNET_TRANSPORT_TESTING_done(), and GNUNET_TRANSPORT_TESTING_start_peer().

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

◆ GNUNET_TRANSPORT_TESTING_restart_peer()

int GNUNET_TRANSPORT_TESTING_restart_peer ( struct GNUNET_TRANSPORT_TESTING_PeerContext p,
GNUNET_SCHEDULER_TaskCallback  restart_cb,
void *  restart_cb_cls 
)

Stops and restarts the given peer, sleeping (!) for 5s in between.

Parameters
pthe peer
restart_cbrestart callback
restart_cb_clscallback closure
Returns
GNUNET_OK in success otherwise GNUNET_SYSERR
Parameters
pthe peer
restart_cbcallback to call when restarted
restart_cb_clscallback closure
Returns
GNUNET_OK in success otherwise GNUNET_SYSERR
Parameters
pthe peer
restart_cbrestart callback
restart_cb_clscallback closure
Returns
GNUNET_OK in success otherwise GNUNET_SYSERR
Parameters
pthe peer
restart_cbcallback to call when restarted
restart_cb_clscallback closure
Returns
GNUNET_OK in success otherwise GNUNET_SYSERR

Definition at line 544 of file transport-testing.c.

548 {
551 
552  /* shutdown */
554  "Stopping peer %u (`%s')\n",
555  p->no,
556  GNUNET_i2s (&p->id));
557  if (NULL != p->ghh)
558  {
560  p->ghh = NULL;
561  }
562  if (NULL != p->th)
563  {
565  p->th = NULL;
566  }
567  if (NULL != p->tmh)
568  {
570  p->tmh = NULL;
571  }
572  for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
573  {
574  ccn = cc->next;
575  if ((cc->p1 == p) ||
576  (cc->p2 == p))
578  }
579  if (NULL != p->ats)
580  {
582  p->ats = NULL;
583  }
584  if (GNUNET_SYSERR ==
585  GNUNET_TESTING_peer_stop (p->peer))
586  {
588  "Failed to stop peer %u (`%s')\n",
589  p->no,
590  GNUNET_i2s (&p->id));
591  return GNUNET_SYSERR;
592  }
593 
594  sleep (5); // YUCK!
595 
597  "Restarting peer %u (`%s')\n",
598  p->no,
599  GNUNET_i2s (&p->id));
600  /* restart */
602  {
604  "Failed to restart peer %u (`%s')\n",
605  p->no,
606  GNUNET_i2s (&p->id));
607  return GNUNET_SYSERR;
608  }
609 
610  GNUNET_assert (NULL == p->start_cb);
611  p->start_cb = restart_cb;
612  p->start_cb_cls = restart_cb_cls;
613 
614  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
615  NULL,
616  p->handlers,
617  p,
620  NULL);
621  GNUNET_assert (NULL != p->th);
622  p->ats = GNUNET_ATS_connectivity_init (p->cfg);
623  p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
625  &get_hello,
626  p);
627  GNUNET_assert (NULL != p->ghh);
628  return GNUNET_OK;
629 }

References get_hello(), GNUNET_assert, GNUNET_ATS_connectivity_done(), GNUNET_ATS_connectivity_init(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_OK, GNUNET_PEERSTORE_iterate(), GNUNET_PEERSTORE_iterate_cancel(), GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY, GNUNET_SYSERR, GNUNET_TESTING_peer_start(), GNUNET_TESTING_peer_stop(), GNUNET_TRANSPORT_AC_ANY, GNUNET_TRANSPORT_core_connect(), GNUNET_TRANSPORT_core_disconnect(), GNUNET_TRANSPORT_hello_get(), GNUNET_TRANSPORT_hello_get_cancel(), GNUNET_TRANSPORT_manipulation_disconnect(), GNUNET_TRANSPORT_TESTING_connect_peers_cancel(), hello_iter_cb(), LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, notify_connect(), notify_disconnect(), p, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p2.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_connect_peers()

struct GNUNET_TRANSPORT_TESTING_ConnectRequest* GNUNET_TRANSPORT_TESTING_connect_peers ( struct GNUNET_TRANSPORT_TESTING_PeerContext p1,
struct GNUNET_TRANSPORT_TESTING_PeerContext p2,
GNUNET_SCHEDULER_TaskCallback  cb,
void *  cls 
)

Connect the given peers and call the callback when both peers report the inbound connection.

Remarks: start_peer's notify_connect callback can be called before.

Parameters
p1peer 1
p2peer 2
cbthe callback to call when both peers notified that they are connected
clscallback cls
Returns
a connect request handle

Connect the given peers and call the callback when both peers report the inbound connection.

Remarks: start_peer's notify_connect callback can be called before.

Parameters
tthtransport testing handle
p1peer 1
p2peer 2
cbthe callback to call when both peers notified that they are connected
clscallback cls
Returns
a connect request handle

Definition at line 777 of file transport-testing.c.

783 {
784  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
787 
788  ccn = NULL;
789  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
790  {
791  if ((cc->p1 == p1) &&
792  (cc->p2 == p2))
793  {
794  ccn = cc;
795  break;
796  }
797  }
798 
800  cc->p1 = p1;
801  cc->p2 = p2;
802  cc->cb = cb;
803  if (NULL != cls)
804  cc->cb_cls = cls;
805  else
806  cc->cb_cls = cc;
807  if (NULL != ccn)
808  {
809  cc->p1_c = ccn->p1_c;
810  cc->p2_c = ccn->p2_c;
811  cc->connected = ccn->connected;
812  }
814  tth->cc_tail,
815  cc);
817  cc);
819  &p2->id,
820  1);
822  "New connect request %p\n",
823  cc);
824  return cc;
825 }
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.
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:1299
int connected
GNUNET_YES if both p1_c and p2_c are GNUNET_YES.
int p2_c
Set if peer2 says the connection is up to peer1.
GNUNET_SCHEDULER_TaskCallback cb
Function to call upon completion.
struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle by which we ask ATS to facilitate the connection.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
int p1_c
Set if peer1 says the connection is up to peer2.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_tail
head DLL of connect contexts
struct GNUNET_PeerIdentity id
Peer identity.
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
static void offer_hello(void *cls)
Offer the current HELLO of P2 to P1.

References GNUNET_TRANSPORT_TESTING_PeerContext::ats, GNUNET_TRANSPORT_TESTING_ConnectRequest::ats_sh, GNUNET_TRANSPORT_TESTING_ConnectRequest::cb, GNUNET_TRANSPORT_TESTING_ConnectRequest::cb_cls, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_Handle::cc_tail, GNUNET_TRANSPORT_TESTING_ConnectRequest::connected, GNUNET_ATS_connectivity_suggest(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, offer_hello(), GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c, GNUNET_TRANSPORT_TESTING_ConnectRequest::tct, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by do_connect().

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

◆ GNUNET_TRANSPORT_TESTING_connect_peers_cancel()

void GNUNET_TRANSPORT_TESTING_connect_peers_cancel ( struct GNUNET_TRANSPORT_TESTING_ConnectRequest cc)

Cancel the request to connect two peers.

You MUST cancel the request if you stop the peers before the peers connected successfully.

Parameters
cca connect request handle

Cancel the request to connect two peers.

Parameters
tthtransport testing handle
cca connect request handle

You MUST cancel the request if you stop the peers before the peers connected successfully.

Parameters
cca connect request handle

Cancel the request to connect two peers.

Parameters
tthtransport testing handle
cca connect request handle

Definition at line 836 of file transport-testing.c.

839 {
840  struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
841 
843  "Canceling connect request!\n");
844  if (NULL != cc->tct)
845  {
847  cc->tct = NULL;
848  }
849  if (NULL != cc->oh)
850  {
852  cc->oh = NULL;
853  }
854  if (NULL != cc->ats_sh)
855  {
857  cc->ats_sh = NULL;
858  }
860  tth->cc_tail,
861  cc);
862  GNUNET_free (cc);
863 }
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.

References GNUNET_TRANSPORT_TESTING_ConnectRequest::ats_sh, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_Handle::cc_tail, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_offer_hello_cancel(), LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::oh, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::tct, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by do_shutdown(), GNUNET_TRANSPORT_TESTING_done(), GNUNET_TRANSPORT_TESTING_restart_peer(), and GNUNET_TRANSPORT_TESTING_stop_peer().

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

◆ GNUNET_TRANSPORT_TESTING_find_connecting_context()

void GNUNET_TRANSPORT_TESTING_find_connecting_context ( struct GNUNET_TRANSPORT_TESTING_PeerContext p1,
struct GNUNET_TRANSPORT_TESTING_PeerContext p2,
GNUNET_TRANSPORT_TESTING_ConnectContextCallback  cb,
void *  cb_cls 
)

Find any connecting context matching the given pair of peers.

Parameters
p1first peer
p2second peer
cbfunction to call
cb_clsclosure for cb

Definition at line 57 of file transport-testing.c.

66 {
67  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
70 
71  for (cc = tth->cc_head; NULL != cc; cc = ccn)
72  {
73  ccn = cc->next;
74  if ((cc->p1 == p1) &&
75  (cc->p2 == p2))
76  cb (cb_cls,
77  cc);
78  }
79 }

References GNUNET_TRANSPORT_TESTING_ConnectRequest::cb, GNUNET_TRANSPORT_TESTING_ConnectRequest::cb_cls, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by GNUNET_TRANSPORT_TESTING_send(), notify_connect(), and notify_disconnect().

Here is the caller graph for this function:

◆ GNUNET_TRANSPORT_TESTING_find_peer()

struct GNUNET_TRANSPORT_TESTING_PeerContext* GNUNET_TRANSPORT_TESTING_find_peer ( struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext ccc,
const struct GNUNET_PeerIdentity peer 
)

Find peer by peer ID.

Parameters
ccccontext to search
peerpeer to look for
Returns
NULL if peer was not found

Definition at line 209 of file transport-testing-main.c.

213 {
214  for (unsigned int i = 0; i < ccc->num_peers; i++)
215  if ((NULL != ccc->p[i]) &&
216  (0 == memcmp (peer,
217  &ccc->p[i]->id,
218  sizeof(*peer))))
219  return ccc->p[i];
220  return NULL;
221 }
unsigned int num_peers
Number of peers involved in the test.
struct GNUNET_TRANSPORT_TESTING_PeerContext ** p
Array with num_peers entries.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References GNUNET_TRANSPORT_TESTING_PeerContext::id, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::num_peers, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::p, and peer.

◆ GNUNET_TRANSPORT_TESTING_connect_check()

int GNUNET_TRANSPORT_TESTING_connect_check ( void *  cls,
struct GNUNET_TRANSPORT_TESTING_Handle tth_,
const char *  test_plugin_,
const char *  test_name_,
unsigned int  num_peers,
char *  cfg_files[] 
)

Common implementation of the GNUNET_TRANSPORT_TESTING_CheckCallback.

Starts and connects the two peers, then invokes the connect_continuation from cls. Sets up a timeout to abort the test, and a shutdown handler to clean up properly on exit.

Parameters
clsclosure of type struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext
tth_initialized testing handle
test_plugin_name of the plugin
test_name_name of the test
num_peersnumber of entries in the cfg_file array
cfg_filesarray of names of configuration files for the peers
Returns
GNUNET_SYSERR on error

Definition at line 508 of file transport-testing-main.c.

515 {
516  static struct GNUNET_GETOPT_CommandLineOption options[] = {
518  };
522  char *argv[] = {
523  (char *) test_name_,
524  "-c",
525  (char *) ccc->config_file,
526  NULL
527  };
528 
530  ccc->cfg_files = cfg_files;
531  ccc->test_plugin = test_plugin_;
532  ccc->test_name = test_name_;
533  ccc->tth = tth_;
535  ccc->p = p;
536  ccc->ip = ip;
537  for (unsigned int i = 0; i < num_peers; i++)
538  {
539  ip[i].off = i;
540  ip[i].ccc = ccc;
541  }
542  if (GNUNET_OK !=
543  GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
544  argv,
545  test_name_,
546  "nohelp",
547  options,
549  ccc))
550  return GNUNET_SYSERR;
551  return ccc->global_ret;
552 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:400
Definition of a command line option.
Closure that must be passed to GNUNET_TRANSPORT_TESTING_connect_check.
const char * test_plugin
Name of the plugin.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Main testing handle.
int global_ret
Result from the main function, set to GNUNET_OK on success.
const char * test_name
Name of the testcase.
void * cls
Closure for rec, nc and nd.
const char * config_file
Which configuration file should we pass to the GNUNET_PROGRAM_run() of the testcase?
char ** cfg_files
Configuration files we have, array with num_peers entries.
struct GNUNET_TRANSPORT_TESTING_InternalPeerContext * ip
Array with num_peers entries.
unsigned int off
Offset of the peer this is about.
struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext * ccc
Overall context of the callback.
static void connect_check_run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Function run from GNUNET_TRANSPORT_TESTING_connect_check once the scheduler is up.

References GNUNET_TRANSPORT_TESTING_InternalPeerContext::ccc, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::cfg_files, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::cls, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::config_file, connect_check_run(), GNUNET_TRANSPORT_TESTING_ConnectCheckContext::global_ret, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_SYSERR, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::ip, num_peers, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::num_peers, GNUNET_TRANSPORT_TESTING_InternalPeerContext::off, options, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::p, p, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::test_name, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::test_plugin, and GNUNET_TRANSPORT_TESTING_ConnectCheckContext::tth.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_main_()

int GNUNET_TRANSPORT_TESTING_main_ ( const char *  argv0,
const char *  filename,
unsigned int  num_peers,
GNUNET_TRANSPORT_TESTING_CheckCallback  check,
void *  check_cls 
)

Setup testcase.

Calls check with the data the test needs.

Parameters
argv0binary name (argv[0])
filenamesource file name (FILE)
num_peersnumber of peers to start
checkmain function to run
check_clsclosure for check
Returns
GNUNET_OK on success

Definition at line 566 of file transport-testing-main.c.

571 {
573  char *test_name;
574  char *test_source;
575  char *test_plugin;
576  char *cfg_names[num_peers];
577  int ret;
578 
579  ret = GNUNET_OK;
580  test_name = GNUNET_TRANSPORT_TESTING_get_test_name (argv0);
581  GNUNET_log_setup (test_name,
582  "WARNING",
583  NULL);
586  test_source);
587  for (unsigned int i = 0; i < num_peers; i++)
588  cfg_names[i] = GNUNET_TRANSPORT_TESTING_get_config_name (argv0,
589  i + 1);
591  if (NULL == tth)
592  {
593  ret = GNUNET_SYSERR;
594  }
595  else
596  {
597  ret = check (check_cls,
598  tth,
599  test_plugin,
600  test_name,
601  num_peers,
602  cfg_names);
604  }
605  for (unsigned int i = 0; i < num_peers; i++)
606  GNUNET_free (cfg_names[i]);
607  GNUNET_free (test_source);
608  GNUNET_free (test_plugin);
609  GNUNET_free (test_name);
610  return ret;
611 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static char * filename
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
char * GNUNET_TRANSPORT_TESTING_get_test_plugin_name(const char *file, const char *test)
Extracts the plugin anme from an absolute file name and the test name.
char * GNUNET_TRANSPORT_TESTING_get_test_source_name(const char *file)
Extracts the filename from an absolute file name and removes the extension.
char * GNUNET_TRANSPORT_TESTING_get_test_name(const char *file)
Extracts the test filename from an absolute file name and removes the extension.
char * GNUNET_TRANSPORT_TESTING_get_config_name(const char *file, int count)
This function takes the filename (e.g.
void GNUNET_TRANSPORT_TESTING_done(struct GNUNET_TRANSPORT_TESTING_Handle *tth)
Clean up the transport testing.
struct GNUNET_TRANSPORT_TESTING_Handle * GNUNET_TRANSPORT_TESTING_init()
Initialize the transport testing.

References filename, GNUNET_free, GNUNET_log_setup(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TRANSPORT_TESTING_done(), GNUNET_TRANSPORT_TESTING_get_config_name(), GNUNET_TRANSPORT_TESTING_get_test_name(), GNUNET_TRANSPORT_TESTING_get_test_plugin_name(), GNUNET_TRANSPORT_TESTING_get_test_source_name(), GNUNET_TRANSPORT_TESTING_init(), num_peers, and ret.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_send()

int GNUNET_TRANSPORT_TESTING_send ( struct GNUNET_TRANSPORT_TESTING_PeerContext sender,
struct GNUNET_TRANSPORT_TESTING_PeerContext receiver,
uint16_t  mtype,
uint16_t  msize,
uint32_t  num,
GNUNET_SCHEDULER_TaskCallback  cont,
void *  cont_cls 
)

Send a test message of type mtype and size msize from peer sender to peer receiver.

The peers should be connected when this function is called.

Parameters
senderthe sending peer
receiverthe receiving peer
mtypemessage type to use
msizesize of the message, at least sizeof (struct GNUNET_TRANSPORT_TESTING_TestMessage)
numunique message number
contcontinuation to call after transmission
cont_clsclosure for cont
Returns
GNUNET_OK if message was queued, GNUNET_NO if peers are not connected GNUNET_SYSERR if msize is illegal

Definition at line 67 of file transport-testing-send.c.

76 {
78  struct GNUNET_MQ_Envelope *env;
80 
81  if (msize < sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage))
82  {
83  GNUNET_break (0);
84  return GNUNET_SYSERR;
85  }
86  cr = NULL;
88  receiver,
89  &find_cr,
90  &cr);
91  if (NULL == cr)
93  sender,
94  &find_cr,
95  &cr);
96  if (NULL == cr)
97  {
98  GNUNET_break (0);
99  return GNUNET_NO;
100  }
101  if (NULL == cr->mq)
102  {
103  GNUNET_break (0);
104  return GNUNET_NO;
105  }
106  {
107  char *receiver_s = GNUNET_strdup (GNUNET_i2s (&receiver->id));
108 
110  "Sending message from peer %u (`%s') -> peer %u (`%s') !\n",
111  sender->no,
112  GNUNET_i2s (&sender->id),
113  receiver->no,
114  receiver_s);
115  GNUNET_free (receiver_s);
116  }
117  env = GNUNET_MQ_msg_extra (test,
118  msize - sizeof(*test),
119  mtype);
120  test->num = htonl (num);
121  memset (&test[1],
122  num,
123  msize - sizeof(*test));
125  cont,
126  cont_cls);
127  GNUNET_MQ_send (cr->mq,
128  env);
129  return GNUNET_OK;
130 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
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:304
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:330
struct GNUNET_MQ_Handle * mq
Message queue for sending from p1 to p2.
unsigned int no
An unique number to identify the peer.
uint32_t num
Monotonically increasing counter throughout the test.
static void find_cr(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
Return cx in cls.
void GNUNET_TRANSPORT_TESTING_find_connecting_context(struct GNUNET_TRANSPORT_TESTING_PeerContext *p1, struct GNUNET_TRANSPORT_TESTING_PeerContext *p2, GNUNET_TRANSPORT_TESTING_ConnectContextCallback cb, void *cb_cls)
Find any connecting context matching the given pair of peers.

References env, find_cr(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_TRANSPORT_TESTING_find_connecting_context(), GNUNET_TRANSPORT_TESTING_PeerContext::id, GNUNET_TRANSPORT_TESTING_ConnectRequest::mq, GNUNET_TRANSPORT_TESTING_PeerContext::no, GNUNET_TRANSPORT_TESTING_TestMessage::num, and receiver().

Referenced by do_send().

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

◆ GNUNET_TRANSPORT_TESTING_simple_send()

void GNUNET_TRANSPORT_TESTING_simple_send ( void *  cls)

Task that sends a minimalistic test message from the first peer to the second peer.

Parameters
clsthe struct GNUNET_TRANSPORT_TESTING_SendClosure which should contain at least two peers, the first two of which should be currently connected
clsthe struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext which should contain at least two peers, the first two of which should be currently connected

Definition at line 178 of file transport-testing-send.c.

179 {
181  int done;
182  size_t msize;
183 
184  if (0 < sc->num_messages)
185  {
186  sc->num_messages--;
187  done = (0 == sc->num_messages);
188  }
189  else
190  {
191  done = 0; /* infinite loop */
192  }
193  msize = sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage);
194  if (NULL != sc->get_size_cb)
195  msize = sc->get_size_cb (sc->num_messages);
196  /* if this was the last message, call the continuation,
197  otherwise call this function again */
198  do_send (sc->ccc,
199  msize,
201  done ? sc->cont_cls : sc);
202 }
static void done()
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
Type of the closure argument to pass to GNUNET_TRANSPORT_TESTING_simple_send() and GNUNET_TRANSPORT_T...
static void do_send(struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc, uint16_t size, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Task that sends a test message from the first peer to the second peer.
void GNUNET_TRANSPORT_TESTING_simple_send(void *cls)
Task that sends a minimalistic test message from the first peer to the second peer.

References do_send(), done(), and sc.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_large_send()

void GNUNET_TRANSPORT_TESTING_large_send ( void *  cls)

Task that sends a large test message from the first peer to the second peer.

Parameters
clsthe struct GNUNET_TRANSPORT_TESTING_SendClosure which should contain at least two peers, the first two of which should be currently connected
clsthe struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext which should contain at least two peers, the first two of which should be currently connected

Definition at line 214 of file transport-testing-send.c.

215 {
217  int done;
218  size_t msize;
219 
220  if (0 < sc->num_messages)
221  {
222  sc->num_messages--;
223  done = (0 == sc->num_messages);
224  }
225  else
226  {
227  done = 0; /* infinite loop */
228  }
229  msize = 2600;
230  if (NULL != sc->get_size_cb)
231  msize = sc->get_size_cb (sc->num_messages);
232  /* if this was the last message, call the continuation,
233  otherwise call this function again */
234  do_send (sc->ccc,
235  msize,
237  done ? sc->cont_cls : sc);
238 }
void GNUNET_TRANSPORT_TESTING_large_send(void *cls)
Task that sends a large test message from the first peer to the second peer.

References do_send(), done(), and sc.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_log_connect()

void GNUNET_TRANSPORT_TESTING_log_connect ( void *  cls,
struct GNUNET_TRANSPORT_TESTING_PeerContext me,
const struct GNUNET_PeerIdentity other 
)

Log a connect event.

Parameters
clsNULL
mepeer that had the event
otherpeer that connected.

Definition at line 37 of file transport-testing-loggers.c.

41 {
42  char *ps;
43 
44  ps = GNUNET_strdup (GNUNET_i2s (&me->id));
46  "Peer %s connected to %u (%s)!\n",
47  GNUNET_i2s (other),
48  me->no,
49  ps);
50  GNUNET_free (ps);
51 }
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.

References GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_strdup, and me.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_log_disconnect()

void GNUNET_TRANSPORT_TESTING_log_disconnect ( void *  cls,
struct GNUNET_TRANSPORT_TESTING_PeerContext me,
const struct GNUNET_PeerIdentity other 
)

Log a disconnect event.

Parameters
clsNULL
mepeer that had the event
otherpeer that disconnected.

Definition at line 62 of file transport-testing-loggers.c.

68 {
69  char *ps;
70 
71  ps = GNUNET_strdup (GNUNET_i2s (&me->id));
73  "Peer `%s' disconnected from %u (%s)!\n",
74  GNUNET_i2s (other),
75  me->no,
76  ps);
77  GNUNET_free (ps);
78 }

References GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_strdup, and me.

Here is the call graph for this function:

◆ GNUNET_TRANSPORT_TESTING_get_test_name()

char* GNUNET_TRANSPORT_TESTING_get_test_name ( const char *  file)

Extracts the test filename from an absolute file name and removes the extension.

Parameters
fileabsolute file name
Returns
resulting test name
Parameters
fileabsolute file name
Returns
the result

Definition at line 66 of file transport-testing-filenames.c.

67 {
68  char *backup = extract_filename (file);
69  char *filename = backup;
70  char *dotexe;
71  char *ret;
72 
73  if (NULL == filename)
74  return NULL;
75 
76  /* remove "lt-" */
77  filename = strstr (filename, "test");
78  if (NULL == filename)
79  {
80  GNUNET_free (backup);
81  return NULL;
82  }
83 
84  /* remove ".exe" */
85  if (NULL != (dotexe = strstr (filename, ".exe")))
86  dotexe[0] = '\0';
88  GNUNET_free (backup);
89  return ret;
90 }
static char * extract_filename(const char *file)
Removes all directory separators from absolute filename.

References extract_filename(), filename, GNUNET_free, GNUNET_strdup, and ret.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

◆ GNUNET_TRANSPORT_TESTING_get_config_name()

char* GNUNET_TRANSPORT_TESTING_get_config_name ( const char *  file,
int  count 
)

This function takes the filename (e.g.

argv[0), removes a "lt-"-prefix and if existing ".exe"-prefix and adds the peer-number

Parameters
filefilename of the test, e.g. argv[0]
countpeer number
Returns
configuration name to use

argv[0), removes a "lt-"-prefix and if existing ".exe"-prefix and adds the peer-number

Parameters
filefilename of the test, e.g. argv[0]
countpeer number
Returns
the result

Definition at line 146 of file transport-testing-filenames.c.

148 {
149  char *filename = extract_filename (file);
150  char *backup = filename;
151  char *dotexe;
152  char *ret;
153 
154  if (NULL == filename)
155  return NULL;
156  /* remove "lt-" */
157  filename = strstr (filename, "test");
158  if (NULL == filename)
159  goto fail;
160  /* remove ".exe" */
161  if (NULL != (dotexe = strstr (filename, ".exe")))
162  dotexe[0] = '\0';
164  "%s_peer%u.conf",
165  filename,
166  count);
167  GNUNET_free (backup);
168  return ret;
169 fail:
170  GNUNET_free (backup);
171  return NULL;
172 }
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.

References extract_filename(), filename, GNUNET_asprintf(), GNUNET_free, and ret.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

◆ GNUNET_TRANSPORT_TESTING_get_test_plugin_name()

char* GNUNET_TRANSPORT_TESTING_get_test_plugin_name ( const char *  file,
const char *  test 
)

Extracts the plugin anme from an absolute file name and the test name.

Parameters
fileabsolute file name
testtest name
Returns
the plugin name

Extracts the plugin anme from an absolute file name and the test name.

Parameters
fileabsolute file name
testtest name
Returns
the result

Definition at line 107 of file transport-testing-filenames.c.

109 {
110  char *filename;
111  char *dotexe;
112  char *e = extract_filename (file);
113  char *t = extract_filename (test);
114  char *ret;
115 
116  if (NULL == e)
117  goto fail;
118  /* remove "lt-" */
119  filename = strstr (e, "tes");
120  if (NULL == filename)
121  goto fail;
122  /* remove ".exe" */
123  if (NULL != (dotexe = strstr (filename, ".exe")))
124  dotexe[0] = '\0';
125 
126  /* find last _ */
127  filename = strstr (filename, t);
128  if (NULL == filename)
129  goto fail;
130  /* copy plugin */
131  filename += strlen (t);
132  if ('\0' != *filename)
133  filename++;
135  goto suc;
136 fail:
137  ret = NULL;
138 suc:
139  GNUNET_free (t);
140  GNUNET_free (e);
141  return ret;
142 }
static struct Experiment * e

References e, extract_filename(), filename, GNUNET_free, GNUNET_strdup, ret, and t.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

◆ GNUNET_TRANSPORT_TESTING_get_test_source_name()

char* GNUNET_TRANSPORT_TESTING_get_test_source_name ( const char *  file)

Extracts the filename from an absolute file name and removes the extension.

Parameters
fileabsolute file name
Returns
the source name
Parameters
fileabsolute file name
Returns
the result

Definition at line 94 of file transport-testing-filenames.c.

95 {
96  char *src = extract_filename (file);
97  char *split;
98 
99  split = strstr (src, ".");
100  if (NULL != split)
101  split[0] = '\0';
102  return src;
103 }

References extract_filename().

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

Variable Documentation

◆ GNUNET_TRANSPORT_TESTING_ReceiveCallback

GNUNET_NETWORK_STRUCT_END typedef void(* GNUNET_TRANSPORT_TESTING_ReceiveCallback) (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_TRANSPORT_TESTING_TestMessage *message) ( void *  cls,
struct GNUNET_TRANSPORT_TESTING_PeerContext receiver,
const struct GNUNET_PeerIdentity sender,
const struct GNUNET_TRANSPORT_TESTING_TestMessage message 
)

Function called by the transport for each received message.

Parameters
clsclosure
receiverreceiver of the message
sendersender of the message
messagethe message

Definition at line 468 of file transport-testing2.h.