testing lib for transport service More...

#include "platform.h"
#include "transport-testing.h"

Include dependency graph for transport-testing.c:

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "transport-testing", __VA_ARGS__)

Functions
static struct GNUNET_TRANSPORT_TESTING_PeerContext *	find_peer_context (struct GNUNET_TRANSPORT_TESTING_Handle tth, const struct GNUNET_PeerIdentity peer)

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

static void	set_p1c (void cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest cx)

static void	set_mq (void cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest cx)

static void	set_p2c (void cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest cx)

static void	clear_p1c (void cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest cx)

static void	clear_p2c (void cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest cx)

static void *	notify_connect (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_MQ_Handle *mq)

static void	offer_hello (void *cls)
	Offer the current HELLO of P2 to P1. More...

static void	notify_disconnect (void cls, const struct GNUNET_PeerIdentity peer, void *handler_cls)

static void	get_hello (void cb_cls, const struct GNUNET_MessageHeader message)

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

void	GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_PeerContext *p)
	Shutdown the given peer. More...

static void	hello_offered (void *cls)
	Function called after the HELLO was passed to the transport service. More...

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)
	Initiate a connection from p1 to p2 by offering p1 p2's HELLO message. More...

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 peers connected successfully. More...

void	GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth)
	Clean up the transport testing. More...

struct GNUNET_TRANSPORT_TESTING_Handle *	GNUNET_TRANSPORT_TESTING_init ()
	Initialize the transport testing. More...

Detailed Description

testing lib for transport service

Author: Matthias Wachs; Christian Grothoff

Definition in file transport-testing.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "transport-testing", __VA_ARGS__)

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

Function Documentation

◆ find_peer_context()

static struct GNUNET_TRANSPORT_TESTING_PeerContext* find_peer_context	(	struct GNUNET_TRANSPORT_TESTING_Handle *	tth,
		const struct GNUNET_PeerIdentity *	peer
	)

static

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

 {
   struct GNUNET_TRANSPORT_TESTING_PeerContext *t;
  
   for (t = tth->p_head; NULL != t; t = t->next)
     if (0 == memcmp (&t->id,
                      peer,
                      sizeof(struct GNUNET_PeerIdentity)))
       return t;
   return NULL;
 }

References GNUNET_SCHEDULER_Task::next, GNUNET_TRANSPORT_TESTING_Handle::p_head, peer, t, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by notify_connect(), and notify_disconnect().

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 57 of file transport-testing.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:

◆ set_p1c()

static void set_p1c	(	void *	cls,
		struct GNUNET_TRANSPORT_TESTING_ConnectRequest *	cx
	)

static

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

 {
   int *found = cls;
  
   if (NULL != found)
     *found = GNUNET_YES;
   cx->p1_c = GNUNET_YES;
 }

References GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c.

Referenced by notify_connect().

Here is the caller graph for this function:

◆ set_mq()

static void set_mq	(	void *	cls,
		struct GNUNET_TRANSPORT_TESTING_ConnectRequest *	cx
	)

static

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

 {
   struct GNUNET_MQ_Handle *mq = cls;
  
   cx->mq = mq;
 }

References mq, and GNUNET_TRANSPORT_TESTING_ConnectRequest::mq.

Referenced by notify_connect(), and notify_disconnect().

Here is the caller graph for this function:

◆ set_p2c()

static void set_p2c	(	void *	cls,
		struct GNUNET_TRANSPORT_TESTING_ConnectRequest *	cx
	)

static

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

 {
   int *found = cls;
  
   if (NULL != found)
     *found = GNUNET_YES;
   cx->p2_c = GNUNET_YES;
 }

References GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c.

Referenced by notify_connect().

Here is the caller graph for this function:

◆ clear_p1c()

static void clear_p1c	(	void *	cls,
		struct GNUNET_TRANSPORT_TESTING_ConnectRequest *	cx
	)

static

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

 {
   int *found = cls;
  
   if (NULL != found)
     *found = GNUNET_YES;
   cx->p1_c = GNUNET_NO;
 }

References GNUNET_NO, GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c.

Referenced by notify_disconnect().

Here is the caller graph for this function:

◆ clear_p2c()

static void clear_p2c	(	void *	cls,
		struct GNUNET_TRANSPORT_TESTING_ConnectRequest *	cx
	)

static

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

 {
   int *found = cls;
  
   if (NULL != found)
     *found = GNUNET_YES;
   cx->p2_c = GNUNET_NO;
 }

References GNUNET_NO, GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c.

Referenced by notify_disconnect().

Here is the caller graph for this function:

◆ notify_connect()

static void* notify_connect	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_MQ_Handle *	mq
	)

static

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

 {
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
   struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
   char *p2_s;
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p2;
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
   int found;
   void *ret;
  
   p2 = find_peer_context (p->tth,
                           peer);
   if (NULL != p->nc)
     ret = p->nc (p->cb_cls,
                  peer,
                  mq);
   else
     ret = NULL;
  
   if (NULL != p2)
     GNUNET_asprintf (&p2_s,
                      "%u (`%s')",
                      p2->no,
                      GNUNET_i2s (&p2->id));
   else
     GNUNET_asprintf (&p2_s,
                      "`%s'",
                      GNUNET_i2s (peer));
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Peers %s connected to peer %u (`%s')\n",
        p2_s,
        p->no,
        GNUNET_i2s (&p->id));
   GNUNET_free (p2_s);
   /* update flags in connecting contexts */
   found = GNUNET_NO;
   GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
                                                     p2,
                                                     &set_p1c,
                                                     &found);
   if (GNUNET_NO == found)
   {
     cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
     cc->p1 = p;
     cc->p2 = p2;
     cc->p1_c = GNUNET_YES;
     GNUNET_CONTAINER_DLL_insert (tth->cc_head,
                                  tth->cc_tail,
                                  cc);
   }
   found = GNUNET_NO;
   GNUNET_TRANSPORT_TESTING_find_connecting_context (p2,
                                                     p,
                                                     &set_p2c,
                                                     &found);
   if (GNUNET_NO == found)
   {
     cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
     cc->p1 = p2;
     cc->p2 = p;
     cc->p1_c = GNUNET_YES;
     GNUNET_CONTAINER_DLL_insert (tth->cc_head,
                                  tth->cc_tail,
                                  cc);
   }
   GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
                                                     p2,
                                                     &set_mq,
                                                     mq);
   /* update set connected flag for all requests */
   for (cc = tth->cc_head; NULL != cc; cc = cc->next)
   {
     if (GNUNET_YES == cc->connected)
       continue;
     if ((GNUNET_YES == cc->p1_c) &&
         (GNUNET_YES == cc->p2_c))
     {
       cc->connected = GNUNET_YES;
       /* stop trying to connect */
       if (NULL != cc->tct)
       {
         GNUNET_SCHEDULER_cancel (cc->tct);
         cc->tct = NULL;
       }
       if (NULL != cc->oh)
       {
         GNUNET_TRANSPORT_offer_hello_cancel (cc->oh);
         cc->oh = NULL;
       }
       if (NULL != cc->ats_sh)
       {
         GNUNET_ATS_connectivity_suggest_cancel (cc->ats_sh);
         cc->ats_sh = NULL;
       }
     }
   }
   /* then notify application */
   for (cc = tth->cc_head; NULL != cc; cc = ccn)
   {
     ccn = cc->next;
     if ((GNUNET_YES == cc->connected) &&
         (NULL != cc->cb))
     {
       cc->cb (cc->cb_cls);
       cc->cb = NULL;     /* only notify once! */
     }
   }
   return ret;
 }

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), and GNUNET_TRANSPORT_TESTING_start_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ offer_hello()

static void offer_hello ( void * cls )

static

Offer the current HELLO of P2 to P1.

Parameters

cls	our `struct GNUNET_TRANSPORT_TESTING_ConnectRequest`

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

 {
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p1 = cc->p1;
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = cc->p2;
  
   cc->tct = NULL;
   {
     char *p2_s = GNUNET_strdup (GNUNET_i2s (&p2->id));
  
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Asking peer %u (`%s') to connect peer %u (`%s'), providing HELLO with %u bytes\n",
          p1->no,
          GNUNET_i2s (&p1->id),
          p2->no,
          p2_s,
          GNUNET_HELLO_size (cc->p2->hello));
     GNUNET_free (p2_s);
   }
  
   if (NULL != cc->oh)
     GNUNET_TRANSPORT_offer_hello_cancel (cc->oh);
   cc->oh =
     GNUNET_TRANSPORT_offer_hello (cc->p1->cfg,
                                   (const struct
                                    GNUNET_MessageHeader *) cc->p2->hello,
                                   &hello_offered,
                                   cc);
 }

References GNUNET_TRANSPORT_TESTING_PeerContext::cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_size(), GNUNET_i2s(), GNUNET_strdup, GNUNET_TRANSPORT_offer_hello(), GNUNET_TRANSPORT_offer_hello_cancel(), GNUNET_TRANSPORT_TESTING_PeerContext::hello, hello_offered(), GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_PeerContext::no, GNUNET_TRANSPORT_TESTING_ConnectRequest::oh, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, and GNUNET_TRANSPORT_TESTING_ConnectRequest::tct.

Referenced by GNUNET_TRANSPORT_TESTING_connect_peers(), hello_offered(), and notify_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_disconnect()

static void notify_disconnect	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	handler_cls
	)

static

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

 {
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
   struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
   char *p2_s;
   /* Find PeerContext */
   int no = 0;
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = NULL;
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
  
   p2 = find_peer_context (p->tth,
                           peer);
   no = p->no;
   if (NULL != p2)
     GNUNET_asprintf (&p2_s,
                      "%u (`%s')",
                      p2->no,
                      GNUNET_i2s (&p2->id));
   else
     GNUNET_asprintf (&p2_s,
                      "`%s'",
                      GNUNET_i2s (peer));
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Peers %s disconnected from peer %u (`%s')\n",
        p2_s,
        no,
        GNUNET_i2s (&p->id));
   GNUNET_free (p2_s);
   /* notify about disconnect */
   if (NULL != p->nd)
     p->nd (p->cb_cls,
            peer,
            handler_cls);
   if (NULL == p2)
     return;
   /* clear MQ, it is now invalid */
   GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
                                                     p2,
                                                     &set_mq,
                                                     NULL);
   /* update set connected flags for all requests */
   GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
                                                     p2,
                                                     &clear_p1c,
                                                     NULL);
   GNUNET_TRANSPORT_TESTING_find_connecting_context (p2,
                                                     p,
                                                     &clear_p2c,
                                                     NULL);
   /* resume connectivity requests as necessary */
   for (cc = tth->cc_head; NULL != cc; cc = cc->next)
   {
     if (GNUNET_NO == cc->connected)
       continue;
     if ((GNUNET_YES != cc->p1_c) ||
         (GNUNET_YES != cc->p2_c))
     {
       cc->connected = GNUNET_NO;
       /* start trying to connect */
       if ((NULL == cc->tct) &&
           (NULL == cc->oh))
         cc->tct = GNUNET_SCHEDULER_add_now (&offer_hello,
                                             cc);
       if (NULL == cc->ats_sh)
         cc->ats_sh = GNUNET_ATS_connectivity_suggest (cc->p1->ats,
                                                       &p2->id,
                                                       1);
     }
   }
 }

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), and GNUNET_TRANSPORT_TESTING_start_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_hello()

static void get_hello	(	void *	cb_cls,
		const struct GNUNET_MessageHeader *	message
	)

static

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

 {
   struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cb_cls;
   struct GNUNET_PeerIdentity hello_id;
  
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct
                                        GNUNET_HELLO_Message *) message,
                                       &hello_id));
   GNUNET_assert (0 == memcmp (&hello_id,
                               &p->id,
                               sizeof(hello_id)));
   GNUNET_free (p->hello);
   p->hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (message);
  
   if (NULL != p->start_cb)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Peer %u (`%s') successfully started\n",
          p->no,
          GNUNET_i2s (&p->id));
     p->start_cb (p->start_cb_cls);
     p->start_cb = NULL;
   }
 }

References GNUNET_TRANSPORT_TESTING_PeerContext::cb_cls, GNUNET_assert, GNUNET_copy_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_OK, LOG, and p.

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), 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_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	a unique number to identify the peer
handlers	functions for receiving messages
nc	connect callback
nd	disconnect callback
cb_cls	closure for callback
start_cb	start callback
start_cb_cls	closure for callback

Returns: the peer context

Definition at line 382 of file transport-testing.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->tmh = GNUNET_TRANSPORT_manipulation_connect (p->cfg);
   p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
                                          NULL,
                                          handlers,
                                          p,
                                          &notify_connect,
                                          &notify_disconnect,
                                          NULL);
   if ((NULL == p->th) ||
       (NULL == p->tmh))
   {
     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->ats = GNUNET_ATS_connectivity_init (p->cfg);
   if (NULL == p->ats)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          "Failed to connect to ATS service for peer `%s': `%s'\n",
          cfgname,
          emsg);
     GNUNET_TRANSPORT_TESTING_stop_peer (p);
     GNUNET_free (emsg);
     return NULL;
   }
   p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
                                        GNUNET_TRANSPORT_AC_ANY,
                                        &get_hello,
                                        p);
   GNUNET_assert (NULL != p->ghh);
   return p;
 }

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_SYSERR, GNUNET_TESTING_configuration_create(), GNUNET_TESTING_peer_configure(), GNUNET_TESTING_peer_get_identity(), GNUNET_TESTING_peer_start(), GNUNET_TRANSPORT_AC_ANY, 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, 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_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	callback to call when restarted
restart_cb_cls	callback closure

Returns: GNUNET_OK in success otherwise GNUNET_SYSERR

Definition at line 544 of file transport-testing.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->ghh)
   {
     GNUNET_TRANSPORT_hello_get_cancel (p->ghh);
     p->ghh = NULL;
   }
   if (NULL != p->th)
   {
     GNUNET_TRANSPORT_core_disconnect (p->th);
     p->th = NULL;
   }
   if (NULL != p->tmh)
   {
     GNUNET_TRANSPORT_manipulation_disconnect (p->tmh);
     p->tmh = 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->ats)
   {
     GNUNET_ATS_connectivity_done (p->ats);
     p->ats = 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,
                                          NULL);
   GNUNET_assert (NULL != p->th);
   p->ats = GNUNET_ATS_connectivity_init (p->cfg);
   p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
                                        GNUNET_TRANSPORT_AC_ANY,
                                        &get_hello,
                                        p);
   GNUNET_assert (NULL != p->ghh);
   return GNUNET_OK;
 }

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_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(), 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_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 638 of file transport-testing.c.

 {
   struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->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 == p) ||
         (cc->p2 == p))
       GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
   }
   if (NULL != p->ghh)
   {
     GNUNET_TRANSPORT_hello_get_cancel (p->ghh);
     p->ghh = NULL;
   }
   if (NULL != p->tmh)
   {
     GNUNET_TRANSPORT_manipulation_disconnect (p->tmh);
     p->tmh = NULL;
   }
   if (NULL != p->th)
   {
     GNUNET_TRANSPORT_core_disconnect (p->th);
     p->th = 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->ats)
   {
     GNUNET_ATS_connectivity_done (p->ats);
     p->ats = 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));
   GNUNET_free (p);
 }

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_OK, GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_stop(), 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:

◆ hello_offered()

static void hello_offered ( void * cls )

static

Function called after the HELLO was passed to the transport service.

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

 {
   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
  
   cc->oh = NULL;
   cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                           &offer_hello,
                                           cc);
 }

References GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_SECONDS, offer_hello(), GNUNET_TRANSPORT_TESTING_ConnectRequest::oh, and GNUNET_TRANSPORT_TESTING_ConnectRequest::tct.

Referenced by offer_hello().

Here is the call graph for this function:

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

Initiate a connection from p1 to p2 by offering p1 p2's HELLO message.

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

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 777 of file transport-testing.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->tct = GNUNET_SCHEDULER_add_now (&offer_hello,
                                       cc);
   cc->ats_sh = GNUNET_ATS_connectivity_suggest (cc->p1->ats,
                                                 &p2->id,
                                                 1);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "New connect request %p\n",
        cc);
   return cc;
 }

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 Tou MUST cancel the request if you stop the peers before the peers connected successfully.

Cancel the request to connect two peers.

Parameters

tth	transport testing handle
cc	a connect request handle

Definition at line 836 of file transport-testing.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->oh)
   {
     GNUNET_TRANSPORT_offer_hello_cancel (cc->oh);
     cc->oh = NULL;
   }
   if (NULL != cc->ats_sh)
   {
     GNUNET_ATS_connectivity_suggest_cancel (cc->ats_sh);
     cc->ats_sh = NULL;
   }
   GNUNET_CONTAINER_DLL_remove (tth->cc_head,
                                tth->cc_tail,
                                cc);
   GNUNET_free (cc);
 }

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_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 872 of file transport-testing.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_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_init()

struct GNUNET_TRANSPORT_TESTING_Handle* GNUNET_TRANSPORT_TESTING_init ( void )

Initialize the transport testing.

Returns: transport testing handle

Definition at line 912 of file transport-testing.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, 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:

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

Function Documentation

◆ find_peer_context()

◆ GNUNET_TRANSPORT_TESTING_find_connecting_context()

◆ set_p1c()

◆ set_mq()

◆ set_p2c()

◆ clear_p1c()

◆ clear_p2c()

◆ notify_connect()

◆ offer_hello()

◆ notify_disconnect()

◆ get_hello()

◆ GNUNET_TRANSPORT_TESTING_start_peer()

◆ GNUNET_TRANSPORT_TESTING_restart_peer()

◆ GNUNET_TRANSPORT_TESTING_stop_peer()

◆ hello_offered()

◆ GNUNET_TRANSPORT_TESTING_connect_peers()

◆ GNUNET_TRANSPORT_TESTING_connect_peers_cancel()

◆ GNUNET_TRANSPORT_TESTING_done()

◆ GNUNET_TRANSPORT_TESTING_init()