transport-testing2.h File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_transport_core_service.h"
#include "gnunet_transport_application_service.h"
#include "gnunet_testing_lib.h"

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.
#define	GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE   12345
	Message type used by GNUNET_TRANSPORT_TESTING_simple_send().
#define	GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2   12346
	Alternative message type for tests.
#define	GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE   12347
	Message type used by #().
#define	GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE   2600
	Size of a message sent with GNUNET_TRANSPORT_TESTING_large_send().

Typedefs
typedef void(*	GNUNET_TRANSPORT_TESTING_ConnectContextCallback) (void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
	Function called on matching connect requests.
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().
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.
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.
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.

Functions
struct GNUNET_TRANSPORT_TESTING_Handle *	GNUNET_TRANSPORT_TESTING_init (void)
	Initialize the transport testing.
void	GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth)
	Clean up the transport testing.
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.
void	GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_PeerContext *pc)
	Shutdown the given 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.
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.
void	GNUNET_TRANSPORT_TESTING_connect_peers_cancel (struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
	Cancel the request to connect two peers.
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.
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.
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.
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.
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.
void	GNUNET_TRANSPORT_TESTING_simple_send (void *cls)
	Task that sends a minimalistic test message from the first peer to the second peer.
void	GNUNET_TRANSPORT_TESTING_large_send (void *cls)
	Task that sends a large test message from the first peer to the second peer.
void	GNUNET_TRANSPORT_TESTING_log_connect (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
	Log a connect event.
void	GNUNET_TRANSPORT_TESTING_log_disconnect (void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
	Log a disconnect event.
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.
char *	GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *executable, const char *testname)
	Extracts the plugin name 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.

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.

Macro Definition Documentation

GNUNET_TRANSPORT_TESTING_main

#define GNUNET_TRANSPORT_TESTING_main	(		num_peers,
			check,
			check_cls
	)

Value:

  GNUNET_TRANSPORT_TESTING_main_ (argv[0],                         \
                                  __FILE__,                        \
                                  num_peers,                       \
                                  check,                           \
                                  check_cls)

Setup testcase.

Calls check with the data the test needs.

Parameters

num_peers	number of peers to start
check	main function to run
check_cls	closure for check

Returns

GNUNET_OK on success

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

{
  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
 
  size_t (*get_size_cb) (unsigned int n);
 
  unsigned int num_messages;
 
  GNUNET_SCHEDULER_TaskCallback cont;
 
  void *cont_cls;
};
 
 
void
GNUNET_TRANSPORT_TESTING_simple_send (void *cls);
 
#define GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE 2600
 
void
GNUNET_TRANSPORT_TESTING_large_send (void *cls);
 
 
/* ********************** log-only convenience functions ************* */
 
 
void
GNUNET_TRANSPORT_TESTING_log_connect (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
  const struct GNUNET_PeerIdentity *other);
 
 
void
GNUNET_TRANSPORT_TESTING_log_disconnect (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
  const struct GNUNET_PeerIdentity *other);
 
 
/* ********************** low-level filename functions *************** */
 
 
char *
GNUNET_TRANSPORT_TESTING_get_test_name (const char *file);
 
 
char *
GNUNET_TRANSPORT_TESTING_get_config_name (const char *file, int count);
 
 
char *
GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *executable,
                                               const char *testname);
 
 
char *
GNUNET_TRANSPORT_TESTING_get_test_source_name (const char *file);
 
#endif
/* end of transport_testing.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 782 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 787 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 792 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 847 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

cls	closure
cc	request matching the query

Definition at line 369 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

cls	closure
num_peers	size of the p array
p	the peers that were launched

Definition at line 401 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

cls	closure
me	peer experiencing the event
other	peer that connected to me

Definition at line 476 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

cls	closure
me	peer experiencing the event
other	peer that disconnected from me

Definition at line 490 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

cls	closure
tth_	initialized testing handle
test_plugin_	name of the plugin
test_name_	name of the test
num_peers	number of entries in the cfg_file array
cfg_files	array of names of configuration files for the peers

Returns

GNUNET_SYSERR on error

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

Function Documentation

GNUNET_TRANSPORT_TESTING_init()

struct GNUNET_TRANSPORT_TESTING_Handle * GNUNET_TRANSPORT_TESTING_init

(

void

)

Initialize the transport testing.

Returns

transport testing handle

Definition at line 852 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
 
  tth = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_Handle);
  tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
                                                 NULL,
                                                 NULL,
                                                 NULL);
  if (NULL == tth->tl_system)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to initialize testing library!\n");
    GNUNET_free (tth);
    return NULL;
  }
  return tth;
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, and GNUNET_TRANSPORT_TESTING_Handle::tl_system.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

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

tth	transport testing handle

Definition at line 812 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ct;
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
  struct GNUNET_TRANSPORT_TESTING_PeerContext *t;
 
  if (NULL == tth)
    return;
  cc = tth->cc_head;
  while (NULL != cc)
  {
    ct = cc->next;
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Developer forgot to cancel connect request!\n");
    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
    cc = ct;
  }
  p = tth->p_head;
  while (NULL != p)
  {
    t = p->next;
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Developer forgot to stop peer!\n");
    GNUNET_TRANSPORT_TESTING_stop_peer (p);
    p = t;
  }
  GNUNET_TESTING_system_destroy (tth->tl_system,
                                 GNUNET_YES);
 
  GNUNET_free (tth);
}

References GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, 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

tth	the testing handle
cfgname	configuration file
peer_id	an identification number for the peer
handlers	functions for receiving messages
nc	connect callback
nd	disconnect callback
cb_cls	closure for nc and nd callback
start_cb	start callback
start_cb_cls	closure for start_cb

Returns

the peer context

Definition at line 375 of file transport-testing2.c.

{
  char *emsg = NULL;
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
  struct GNUNET_PeerIdentity dummy;
  unsigned int i;
 
  if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "File not found: `%s'\n",
         cfgname);
    return NULL;
  }
 
  p = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_PeerContext);
  p->tth = tth;
  p->nc = nc;
  p->nd = nd;
  if (NULL != handlers)
  {
    for (i = 0; NULL != handlers[i].cb; i++)
      ;
    p->handlers = GNUNET_new_array (i + 1,
                                    struct GNUNET_MQ_MessageHandler);
    GNUNET_memcpy (p->handlers,
                   handlers,
                   i * sizeof(struct GNUNET_MQ_MessageHandler));
  }
  if (NULL != cb_cls)
    p->cb_cls = cb_cls;
  else
    p->cb_cls = p;
  p->start_cb = start_cb;
  if (NULL != start_cb_cls)
    p->start_cb_cls = start_cb_cls;
  else
    p->start_cb_cls = p;
  GNUNET_CONTAINER_DLL_insert (tth->p_head,
                               tth->p_tail,
                               p);
 
  /* Create configuration and call testing lib to modify it */
  p->cfg = GNUNET_CONFIGURATION_create ();
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONFIGURATION_load (p->cfg, cfgname));
  if (GNUNET_SYSERR ==
      GNUNET_TESTING_configuration_create (tth->tl_system,
                                           p->cfg))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Testing library failed to create unique configuration based on `%s'\n",
         cfgname);
    GNUNET_CONFIGURATION_destroy (p->cfg);
    GNUNET_free (p);
    return NULL;
  }
 
  p->no = peer_id;
  /* Configure peer with configuration */
  p->peer = GNUNET_TESTING_peer_configure (tth->tl_system,
                                           p->cfg,
                                           p->no,
                                           NULL,
                                           &emsg);
  if (NULL == p->peer)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Testing library failed to create unique configuration based on `%s': `%s'\n",
         cfgname,
         emsg);
    GNUNET_TRANSPORT_TESTING_stop_peer (p);
    GNUNET_free (emsg);
    return NULL;
  }
 
  if (GNUNET_OK != GNUNET_TESTING_peer_start (p->peer))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Testing library failed to create unique configuration based on `%s'\n",
         cfgname);
    GNUNET_TRANSPORT_TESTING_stop_peer (p);
    return NULL;
  }
 
  memset (&dummy,
          '\0',
          sizeof(dummy));
  GNUNET_TESTING_peer_get_identity (p->peer,
                                    &p->id);
  if (0 == memcmp (&dummy,
                   &p->id,
                   sizeof(struct GNUNET_PeerIdentity)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Testing library failed to obtain peer identity for peer %u\n",
         p->no);
    GNUNET_TRANSPORT_TESTING_stop_peer (p);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Peer %u configured with identity `%s'\n",
       p->no,
       GNUNET_i2s_full (&p->id));
  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
                                         NULL,
                                         handlers,
                                         p,
                                         &notify_connect,
                                         &notify_disconnect);
  if (NULL == p->th)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to connect to transport service for peer `%s': `%s'\n",
         cfgname,
         emsg);
    GNUNET_TRANSPORT_TESTING_stop_peer (p);
    GNUNET_free (emsg);
    return NULL;
  }
  p->ah = GNUNET_TRANSPORT_application_init (p->cfg);
  if (NULL == p->ah)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to connect to TNG service for peer `%s': `%s'\n",
         cfgname,
         emsg);
    GNUNET_TRANSPORT_TESTING_stop_peer (p);
    GNUNET_free (emsg);
    return NULL;
  }
  p->ph = GNUNET_PEERSTORE_connect (p->cfg);
  // FIXME Error handling
  p->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, p);
 
  return p;
}

References dummy, GNUNET_assert, 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_TRANSPORT_application_init(), GNUNET_TRANSPORT_core_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

p

the peer

Definition at line 615 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
  /* shutdown */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Stopping peer %u (`%s')\n",
       p->no,
       GNUNET_i2s (&p->id));
 
  for (cc = tth->cc_head; NULL != cc; cc = ccn)
  {
    ccn = cc->next;
    if ((cc->p1 == p) ||
        (cc->p2 == p))
      GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
  }
  if (NULL != p->pic)
  {
    GNUNET_PEERSTORE_iteration_stop (p->pic);
    p->pic = NULL;
  }
  if (NULL != p->th)
  {
    GNUNET_TRANSPORT_core_disconnect (p->th);
    p->th = NULL;
  }
  if (NULL != p->ah)
  {
    GNUNET_TRANSPORT_application_done (p->ah);
    p->ah = NULL;
  }
  if (NULL != p->ph)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Disconnecting from PEERSTORE service\n");
    GNUNET_PEERSTORE_disconnect (p->ph);
    p->ph = NULL;
  }
 
  if (NULL != p->peer)
  {
    if (GNUNET_OK !=
        GNUNET_TESTING_peer_stop (p->peer))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Testing lib failed to stop peer %u (`%s')\n",
           p->no,
           GNUNET_i2s (&p->id));
    }
    GNUNET_TESTING_peer_destroy (p->peer);
    p->peer = NULL;
  }
  if (NULL != p->hello)
  {
    GNUNET_free (p->hello);
    p->hello = NULL;
  }
  if (NULL != p->cfg)
  {
    GNUNET_CONFIGURATION_destroy (p->cfg);
    p->cfg = NULL;
  }
  if (NULL != p->handlers)
  {
    GNUNET_free (p->handlers);
    p->handlers = NULL;
  }
  GNUNET_CONTAINER_DLL_remove (tth->p_head,
                               tth->p_tail,
                               p);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Peer %u (`%s') stopped\n",
       p->no,
       GNUNET_i2s (&p->id));
  if (NULL != p->rh_task)
    GNUNET_SCHEDULER_cancel (p->rh_task);
  p->rh_task = NULL;
  GNUNET_free (p);
}

References GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_iteration_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_application_done(), GNUNET_TRANSPORT_core_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

p	the peer
restart_cb	restart callback
restart_cb_cls	callback closure

Returns

GNUNET_OK in success otherwise GNUNET_SYSERR

Definition at line 525 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
 
  /* shutdown */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Stopping peer %u (`%s')\n",
       p->no,
       GNUNET_i2s (&p->id));
  if (NULL != p->pic)
  {
    GNUNET_PEERSTORE_iteration_stop (p->pic);
    p->pic = NULL;
  }
  if (NULL != p->th)
  {
    GNUNET_TRANSPORT_core_disconnect (p->th);
    p->th = NULL;
  }
  for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
  {
    ccn = cc->next;
    if ((cc->p1 == p) ||
        (cc->p2 == p))
      GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
  }
  if (NULL != p->ah)
  {
    GNUNET_TRANSPORT_application_done (p->ah);
    p->ah = NULL;
  }
  if (GNUNET_SYSERR ==
      GNUNET_TESTING_peer_stop (p->peer))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to stop peer %u (`%s')\n",
         p->no,
         GNUNET_i2s (&p->id));
    return GNUNET_SYSERR;
  }
 
  sleep (5);  // YUCK!
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Restarting peer %u (`%s')\n",
       p->no,
       GNUNET_i2s (&p->id));
  /* restart */
  if (GNUNET_SYSERR == GNUNET_TESTING_peer_start (p->peer))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed to restart peer %u (`%s')\n",
         p->no,
         GNUNET_i2s (&p->id));
    return GNUNET_SYSERR;
  }
 
  GNUNET_assert (NULL == p->start_cb);
  p->start_cb = restart_cb;
  p->start_cb_cls = restart_cb_cls;
 
  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
                                         NULL,
                                         p->handlers,
                                         p,
                                         &notify_connect,
                                         &notify_disconnect);
  GNUNET_assert (NULL != p->th);
  p->ah = GNUNET_TRANSPORT_application_init (p->cfg);
  p->pic = GNUNET_PEERSTORE_iteration_start (p->ph,
                                           "transport",
                                           &p->id,
                                           GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
                                           hello_iter_cb,
                                           p);
  GNUNET_assert (NULL != p->pic);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_OK, GNUNET_PEERSTORE_iteration_start(), GNUNET_PEERSTORE_iteration_stop(), GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY, GNUNET_SYSERR, GNUNET_TRANSPORT_application_done(), GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_core_connect(), GNUNET_TRANSPORT_core_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

p1	peer 1
p2	peer 2
cb	the callback to call when both peers notified that they are connected
cls	callback cls

Returns

a connect request handle

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

FIXME maybe schedule the application_validate somehow Initiate a connection from p1 to p2 by offering p1 p2's HELLO message

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

Parameters

tth	transport testing handle
p1	peer 1
p2	peer 2
cb	the callback to call when both peers notified that they are connected
cls	callback cls

Returns

a connect request handle

Definition at line 730 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
 
  ccn = NULL;
  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
  {
    if ((cc->p1 == p1) &&
        (cc->p2 == p2))
    {
      ccn = cc;
      break;
    }
  }
 
  cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
  cc->p1 = p1;
  cc->p2 = p2;
  cc->cb = cb;
  if (NULL != cls)
    cc->cb_cls = cls;
  else
    cc->cb_cls = cc;
  if (NULL != ccn)
  {
    cc->p1_c = ccn->p1_c;
    cc->p2_c = ccn->p2_c;
    cc->connected = ccn->connected;
  }
  GNUNET_CONTAINER_DLL_insert (tth->cc_head,
                               tth->cc_tail,
                               cc);
  cc->ah_sh = GNUNET_TRANSPORT_application_suggest (cc->p1->ah,
                                                    &p2->id,
                                                    GNUNET_MQ_PRIO_BEST_EFFORT,
                                                    GNUNET_BANDWIDTH_ZERO);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New connect request %p\n",
       cc);
  return cc;
}

References GNUNET_TRANSPORT_TESTING_PeerContext::ah, GNUNET_TRANSPORT_TESTING_ConnectRequest::ah_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_BANDWIDTH_ZERO, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_new, GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c, 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

cc	a connect request handle

Definition at line 781 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Canceling connect request!\n");
  if (NULL != cc->tct)
  {
    GNUNET_SCHEDULER_cancel (cc->tct);
    cc->tct = NULL;
  }
  if (NULL != cc->ah_sh)
  {
    GNUNET_TRANSPORT_application_suggest_cancel (cc->ah_sh);
    cc->ah_sh = NULL;
  }
  GNUNET_CONTAINER_DLL_remove (tth->cc_head,
                               tth->cc_tail,
                               cc);
  GNUNET_free (cc);
}

References GNUNET_TRANSPORT_TESTING_ConnectRequest::ah_sh, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_Handle::cc_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_application_suggest_cancel(), LOG, 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

p1	first peer
p2	second peer
cb	function to call
cb_cls	closure for cb

Definition at line 58 of file transport-testing2.c.

{
  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
 
  for (cc = tth->cc_head; NULL != cc; cc = ccn)
  {
    ccn = cc->next;
    if ((cc->p1 == p1) &&
        (cc->p2 == p2))
      cb (cb_cls,
          cc);
  }
}

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

ccc	context to search
peer	peer to look for

Returns

NULL if peer was not found

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

{
  for (unsigned int i = 0; i < ccc->num_peers; i++)
    if ((NULL != ccc->p[i]) &&
        (0 == memcmp (peer,
                      &ccc->p[i]->id,
                      sizeof(*peer))))
      return ccc->p[i];
  return NULL;
}

References GNUNET_TRANSPORT_TESTING_PeerContext::id, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::num_peers, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::p, and GNUNET_TRANSPORT_TESTING_PeerContext::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

cls	closure of type struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext
tth_	initialized testing handle
test_plugin_	name of the plugin
test_name_	name of the test
num_peers	number of entries in the cfg_file array
cfg_files	array of names of configuration files for the peers

Returns

GNUNET_SYSERR on error

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

{
  static struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls;
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p[num_peers];
  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext ip[num_peers];
  char *argv[] = {
    (char *) test_name_,
    "-c",
    (char *) ccc->config_file,
    NULL
  };
 
  ccc->num_peers = num_peers;
  ccc->cfg_files = cfg_files;
  ccc->test_plugin = test_plugin_;
  ccc->test_name = test_name_;
  ccc->tth = tth_;
  ccc->global_ret = GNUNET_OK;
  ccc->p = p;
  ccc->ip = ip;
  for (unsigned int i = 0; i < num_peers; i++)
  {
    ip[i].off = i;
    ip[i].ccc = ccc;
  }
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
                          argv,
                          test_name_,
                          "nohelp",
                          options,
                          &connect_check_run,
                          ccc))
    return GNUNET_SYSERR;
  return ccc->global_ret;
}

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, p, GNUNET_TRANSPORT_TESTING_ConnectCheckContext::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

argv0	binary name (argv[0])
filename	source file name (FILE)
num_peers	number of peers to start
check	main function to run
check_cls	closure for check

Returns

GNUNET_OK on success

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

{
  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
  char *test_name;
  char *test_source;
  char *test_plugin;
  char *cfg_names[num_peers];
  int ret;
 
  ret = GNUNET_OK;
  test_name = GNUNET_TRANSPORT_TESTING_get_test_name (argv0);
  GNUNET_log_setup (test_name,
                    "WARNING",
                    NULL);
  test_source = GNUNET_TRANSPORT_TESTING_get_test_source_name (filename);
  test_plugin = GNUNET_TRANSPORT_TESTING_get_test_plugin_name (argv0,
                                                               test_source);
  for (unsigned int i = 0; i < num_peers; i++)
    cfg_names[i] = GNUNET_TRANSPORT_TESTING_get_config_name (argv0,
                                                             i + 1);
  tth = GNUNET_TRANSPORT_TESTING_init ();
  if (NULL == tth)
  {
    ret = GNUNET_SYSERR;
  }
  else
  {
    ret = check (check_cls,
                 tth,
                 test_plugin,
                 test_name,
                 num_peers,
                 cfg_names);
    GNUNET_TRANSPORT_TESTING_done (tth);
  }
  for (unsigned int i = 0; i < num_peers; i++)
    GNUNET_free (cfg_names[i]);
  GNUNET_free (test_source);
  GNUNET_free (test_plugin);
  GNUNET_free (test_name);
  return ret;
}

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

sender	the sending peer
receiver	the receiving peer
mtype	message type to use
msize	size of the message, at least sizeof (struct GNUNET_TRANSPORT_TESTING_TestMessage)
num	unique message number
cont	continuation to call after transmission
cont_cls	closure 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-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cr;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_TESTING_TestMessage *test;
 
  if (msize < sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  cr = NULL;
  GNUNET_TRANSPORT_TESTING_find_connecting_context (sender,
                                                    receiver,
                                                    &find_cr,
                                                    &cr);
  if (NULL == cr)
    GNUNET_TRANSPORT_TESTING_find_connecting_context (receiver,
                                                      sender,
                                                      &find_cr,
                                                      &cr);
  if (NULL == cr)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  if (NULL == cr->mq)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  {
    char *receiver_s = GNUNET_strdup (GNUNET_i2s (&receiver->id));
 
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Sending message from peer %u (`%s') -> peer %u (`%s') !\n",
                sender->no,
                GNUNET_i2s (&sender->id),
                receiver->no,
                receiver_s);
    GNUNET_free (receiver_s);
  }
  env = GNUNET_MQ_msg_extra (test,
                             msize - sizeof(*test),
                             mtype);
  test->num = htonl (num);
  memset (&test[1],
          num,
          msize - sizeof(*test));
  GNUNET_MQ_notify_sent (env,
                         cont,
                         cont_cls);
  GNUNET_MQ_send (cr->mq,
                  env);
  return GNUNET_OK;
}

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

cls	the struct GNUNET_TRANSPORT_TESTING_SendClosure which should contain at least two peers, the first two of which should be currently connected
cls	the 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-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
  int done;
  size_t msize;
 
  if (0 < sc->num_messages)
  {
    sc->num_messages--;
    done = (0 == sc->num_messages);
  }
  else
  {
    done = 0;   /* infinite loop */
  }
  msize = sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage);
  if (NULL != sc->get_size_cb)
    msize = sc->get_size_cb (sc->num_messages);
  /* if this was the last message, call the continuation,
     otherwise call this function again */
  do_send (sc->ccc,
           msize,
           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_simple_send,
           done ? sc->cont_cls : sc);
}

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

Referenced by GNUNET_TRANSPORT_TESTING_simple_send().

Here is the call graph for this function:

Here is the caller 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

cls	the struct GNUNET_TRANSPORT_TESTING_SendClosure which should contain at least two peers, the first two of which should be currently connected
cls	the 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-send2.c.

{
  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
  int done;
  size_t msize;
 
  if (0 < sc->num_messages)
  {
    sc->num_messages--;
    done = (0 == sc->num_messages);
  }
  else
  {
    done = 0;   /* infinite loop */
  }
  msize = 2600;
  if (NULL != sc->get_size_cb)
    msize = sc->get_size_cb (sc->num_messages);
  /* if this was the last message, call the continuation,
     otherwise call this function again */
  do_send (sc->ccc,
           msize,
           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_large_send,
           done ? sc->cont_cls : sc);
}

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

Referenced by GNUNET_TRANSPORT_TESTING_large_send().

Here is the call graph for this function:

Here is the caller 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

cls	NULL
me	peer that had the event
other	peer that connected.

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

{
  char *ps;
 
  ps = GNUNET_strdup (GNUNET_i2s (&me->id));
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Peer %s connected to %u (%s)!\n",
              GNUNET_i2s (other),
              me->no,
              ps);
  GNUNET_free (ps);
}

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

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

cls	NULL
me	peer that had the event
other	peer that disconnected.

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

{
  char *ps;
 
  ps = GNUNET_strdup (GNUNET_i2s (&me->id));
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Peer `%s' disconnected from %u (%s)!\n",
              GNUNET_i2s (other),
              me->no,
              ps);
  GNUNET_free (ps);
}

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

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

file	absolute file name

Returns

resulting test name

Parameters

file	absolute file name

Returns

the result

Definition at line 73 of file transport-testing-filenames2.c.

{
  char *backup = extract_filename (file);
  char *filename = backup;
  char *dotexe;
  char *ret;
 
  if (NULL == filename)
    return NULL;
 
  /* remove "lt-" */
  filename = strstr (filename, "test");
  if (NULL == filename)
  {
    GNUNET_free (backup);
    return NULL;
  }
 
  /* remove ".exe" */
  if (NULL != (dotexe = strstr (filename, ".exe")))
    dotexe[0] = '\0';
  ret = GNUNET_strdup (filename);
  GNUNET_free (backup);
  return ret;
}

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

file	filename of the test, e.g. argv[0]
count	peer number

Returns

configuration name to use

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

Parameters

file	filename of the test, e.g. argv[0]
count	peer number

Returns

the result

Definition at line 174 of file transport-testing-filenames2.c.

{
  char *filename = extract_filename (file);
  char *backup = filename;
  char *dotexe;
  char *ret;
 
  if (NULL == filename)
    return NULL;
  /* remove "lt-" */
  filename = strstr (filename, "test");
  if (NULL == filename)
    goto fail;
  /* remove ".exe" */
  if (NULL != (dotexe = strstr (filename, ".exe")))
    dotexe[0] = '\0';
  GNUNET_asprintf (&ret,
                   "%s_peer%u.conf",
                   filename,
                   count);
  GNUNET_free (backup);
  return ret;
fail:
  GNUNET_free (backup);
  return NULL;
}

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 name from an absolute file name and the test name.

Parameters

file	absolute file name
test	test name

Returns

the plugin name

Parameters

file	absolute file name
test	test name

Returns

the result

Definition at line 127 of file transport-testing-filenames2.c.

{
  char *filename;
  char *dotexe;
  char *e = extract_filename (file);
  char *t = extract_filename (test);
  char *ret;
 
  if (NULL == e)
    goto fail;
  /* remove "lt-" */
  filename = strstr (e, "tes");
  if (NULL == filename)
    goto fail;
  /* remove ".exe" */
  if (NULL != (dotexe = strstr (filename, ".exe")))
    dotexe[0] = '\0';
 
  /* find last _ */
  filename = strstr (filename, t);
  if (NULL == filename)
    goto fail;
  /* copy plugin */
  filename += strlen (t);
  if ('\0' != *filename)
    filename++;
  ret = GNUNET_strdup (filename);
  goto suc;
fail:
  ret = NULL;
suc:
  GNUNET_free (t);
  GNUNET_free (e);
  return ret;
}

References 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

file	absolute file name

Returns

the source name

Parameters

file	absolute file name

Returns

the result

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

{
  char *src = extract_filename (file);
  char *split;
 
  split = strstr (src, ".");
  if (NULL != split)
    split[0] = '\0';
  return src;
}

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

cls	closure
receiver	receiver of the message
sender	sender of the message
message	the message

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