GNUnet  0.10.x
Macros | Functions
transport-testing.c File Reference

testing lib for transport service More...

#include "transport-testing.h"
Include dependency graph for transport-testing.c:

Go to the source code of this file.

Macros

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

Functions

static struct GNUNET_TRANSPORT_TESTING_PeerContextfind_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_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...
 
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_ConnectRequestGNUNET_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 succesfully. More...
 
void GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth)
 Clean up the transport testing. More...
 
struct GNUNET_TRANSPORT_TESTING_HandleGNUNET_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__)

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 33 of file transport-testing.c.

References GNUNET_TRANSPORT_TESTING_PeerContext::id, GNUNET_TRANSPORT_TESTING_PeerContext::next, GNUNET_TRANSPORT_TESTING_Handle::p_head, and t.

Referenced by notify_connect(), and notify_disconnect().

35 {
37 
38  for (t = tth->p_head; NULL != t; t = t->next)
39  if (0 == memcmp (&t->id,
40  peer,
41  sizeof (struct GNUNET_PeerIdentity)))
42  return t;
43  return NULL;
44 }
struct GNUNET_PeerIdentity id
Peer identity.
Context for a single peer.
static struct GNUNET_SCHEDULER_Task * t
Main task.
struct GNUNET_TRANSPORT_TESTING_PeerContext * next
Next element in the DLL.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
The identity of the host (wraps the signing key of the peer).
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 56 of file transport-testing.c.

References GNUNET_TRANSPORT_TESTING_ConnectRequest::cb, 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().

60 {
61  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
64 
65  for (cc = tth->cc_head; NULL != cc; cc = ccn)
66  {
67  ccn = cc->next;
68  if ( (cc->p1 == p1) &&
69  (cc->p2 == p2) )
70  cb (cb_cls,
71  cc);
72  }
73 }
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
GNUNET_SCHEDULER_TaskCallback cb
Function to call upon completion.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
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 77 of file transport-testing.c.

References GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c.

Referenced by notify_connect().

79 {
80  int *found = cls;
81 
82  if (NULL != found)
83  *found = GNUNET_YES;
84  cx->p1_c = GNUNET_YES;
85 }
int p1_c
Set if peer1 says the connection is up to peer2.
#define GNUNET_YES
Definition: gnunet_common.h:80
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 89 of file transport-testing.c.

References mq, and GNUNET_TRANSPORT_TESTING_ConnectRequest::mq.

Referenced by notify_connect(), and notify_disconnect().

91 {
92  struct GNUNET_MQ_Handle *mq = cls;
93 
94  cx->mq = mq;
95 }
struct GNUNET_MQ_Handle * mq
Message queue for sending from p1 to p2.
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
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 99 of file transport-testing.c.

References GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c.

Referenced by notify_connect().

101 {
102  int *found = cls;
103 
104  if (NULL != found)
105  *found = GNUNET_YES;
106  cx->p2_c = GNUNET_YES;
107 }
#define GNUNET_YES
Definition: gnunet_common.h:80
int p2_c
Set if peer2 says the connection is up to peer1.
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 111 of file transport-testing.c.

References GNUNET_NO, GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c.

Referenced by notify_disconnect().

113 {
114  int *found = cls;
115 
116  if (NULL != found)
117  *found = GNUNET_YES;
118  cx->p1_c = GNUNET_NO;
119 }
#define GNUNET_NO
Definition: gnunet_common.h:81
int p1_c
Set if peer1 says the connection is up to peer2.
#define GNUNET_YES
Definition: gnunet_common.h:80
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 123 of file transport-testing.c.

References GNUNET_NO, GNUNET_YES, and GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c.

Referenced by notify_disconnect().

125 {
126  int *found = cls;
127 
128  if (NULL != found)
129  *found = GNUNET_YES;
130  cx->p2_c = GNUNET_NO;
131 }
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_YES
Definition: gnunet_common.h:80
int p2_c
Set if peer2 says the connection is up to peer1.
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 135 of file transport-testing.c.

References GNUNET_TRANSPORT_TESTING_ConnectRequest::ats_sh, GNUNET_TRANSPORT_TESTING_ConnectRequest::cb, GNUNET_TRANSPORT_TESTING_PeerContext::cb_cls, GNUNET_TRANSPORT_TESTING_ConnectRequest::cb_cls, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_Handle::cc_tail, GNUNET_TRANSPORT_TESTING_ConnectRequest::connected, find_peer_context(), GNUNET_asprintf(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_TRANSPORT_offer_hello_cancel(), GNUNET_TRANSPORT_TESTING_find_connecting_context(), GNUNET_YES, GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_PeerContext::nc, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, GNUNET_TRANSPORT_TESTING_PeerContext::no, offer_hello(), GNUNET_TRANSPORT_TESTING_ConnectRequest::oh, p, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c, ret, set_mq(), set_p1c(), set_p2c(), GNUNET_TRANSPORT_TESTING_ConnectRequest::tct, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), and GNUNET_TRANSPORT_TESTING_start_peer().

138 {
140  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
141  char *p2_s;
145  int found;
146  void *ret;
147 
148  p2 = find_peer_context (p->tth,
149  peer);
150  if (NULL != p->nc)
151  ret = p->nc (p->cb_cls,
152  peer,
153  mq);
154  else
155  ret = NULL;
156 
157  if (NULL != p2)
158  GNUNET_asprintf (&p2_s,
159  "%u (`%s')",
160  p2->no,
161  GNUNET_i2s (&p2->id));
162  else
163  GNUNET_asprintf (&p2_s,
164  "`%s'",
165  GNUNET_i2s (peer));
167  "Peers %s connected to peer %u (`%s')\n",
168  p2_s,
169  p->no,
170  GNUNET_i2s (&p->id));
171  GNUNET_free (p2_s);
172  /* update flags in connecting contexts */
173  found = GNUNET_NO;
175  p2,
176  &set_p1c,
177  &found);
178  if (GNUNET_NO == found)
179  {
181  cc->p1 = p;
182  cc->p2 = p2;
183  cc->p1_c = GNUNET_YES;
185  tth->cc_tail,
186  cc);
187  }
188  found = GNUNET_NO;
190  p,
191  &set_p2c,
192  &found);
193  if (GNUNET_NO == found)
194  {
196  cc->p1 = p2;
197  cc->p2 = p;
198  cc->p1_c = GNUNET_YES;
200  tth->cc_tail,
201  cc);
202  }
204  p2,
205  &set_mq,
206  mq);
207  /* update set connected flag for all requests */
208  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
209  {
210  if (GNUNET_YES == cc->connected)
211  continue;
212  if ( (GNUNET_YES == cc->p1_c) &&
213  (GNUNET_YES == cc->p2_c) )
214  {
215  cc->connected = GNUNET_YES;
216  /* stop trying to connect */
217  if (NULL != cc->tct)
218  {
220  cc->tct = NULL;
221  }
222  if (NULL != cc->oh)
223  {
225  cc->oh = NULL;
226  }
227  if (NULL != cc->ats_sh)
228  {
230  cc->ats_sh = NULL;
231  }
232  }
233  }
234  /* then notify application */
235  for (cc = tth->cc_head; NULL != cc; cc = ccn)
236  {
237  ccn = cc->next;
238  if ( (GNUNET_YES == cc->connected) &&
239  (NULL != cc->cb) )
240  {
241  cc->cb (cc->cb_cls);
242  cc->cb = NULL; /* only notify once! */
243  }
244  }
245  return ret;
246 }
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
static struct GNUNET_TRANSPORT_TESTING_PeerContext * find_peer_context(struct GNUNET_TRANSPORT_TESTING_Handle *tth, const struct GNUNET_PeerIdentity *peer)
struct GNUNET_PeerIdentity id
Peer identity.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.
Context for a single peer.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle by which we ask ATS to faciliate the connection.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
static void set_p1c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
int p1_c
Set if peer1 says the connection is up to peer2.
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
int connected
GNUNET_YES if both p1_c and p2_c are GNUNET_YES.
GNUNET_SCHEDULER_TaskCallback cb
Function to call upon completion.
GNUNET_TRANSPORT_NotifyConnect nc
Notify connect callback.
static void set_p2c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
static void set_mq(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
#define GNUNET_YES
Definition: gnunet_common.h:80
void * cb_cls
Closure for the nc and nd callbacks.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
int p2_c
Set if peer2 says the connection is up to peer1.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_tail
head DLL of connect contexts
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
clsour struct GNUNET_TRANSPORT_TESTING_ConnectRequest

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

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(), notify_connect(), and notify_disconnect().

720 {
722  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1 = cc->p1;
723  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = cc->p2;
724 
725  cc->tct = NULL;
726  {
727  char *p2_s = GNUNET_strdup (GNUNET_i2s (&p2->id));
728 
730  "Asking peer %u (`%s') to connect peer %u (`%s'), providing HELLO with %u bytes\n",
731  p1->no,
732  GNUNET_i2s (&p1->id),
733  p2->no,
734  p2_s,
735  GNUNET_HELLO_size (cc->p2->hello));
736  GNUNET_free (p2_s);
737  }
738 
739  if (NULL != cc->oh)
741  cc->oh =
743  (const struct GNUNET_MessageHeader *) cc->p2->hello,
744  &hello_offered,
745  cc);
746 }
Handle for a request to connect two peers.
struct GNUNET_CONFIGURATION_Handle * cfg
Peer's configuration.
struct GNUNET_PeerIdentity id
Peer identity.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.
Context for a single peer.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
struct GNUNET_HELLO_Message * hello
Peers HELLO Message.
static void hello_offered(void *cls)
Function called after the HELLO was passed to the transport service.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
struct GNUNET_TRANSPORT_OfferHelloHandle * GNUNET_TRANSPORT_offer_hello(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_MessageHeader *hello, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Offer the transport service the HELLO of another peer.
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:649
Header for all communications.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
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 259 of file transport-testing.c.

References GNUNET_TRANSPORT_TESTING_PeerContext::ats, GNUNET_TRANSPORT_TESTING_ConnectRequest::ats_sh, GNUNET_TRANSPORT_TESTING_PeerContext::cb_cls, GNUNET_TRANSPORT_TESTING_Handle::cc_head, clear_p1c(), clear_p2c(), GNUNET_TRANSPORT_TESTING_ConnectRequest::connected, find_peer_context(), GNUNET_asprintf(), GNUNET_ATS_connectivity_suggest(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_TRANSPORT_TESTING_find_connecting_context(), GNUNET_YES, GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_PeerContext::nd, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, GNUNET_TRANSPORT_TESTING_PeerContext::no, offer_hello(), GNUNET_TRANSPORT_TESTING_ConnectRequest::oh, p, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1_c, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2_c, set_mq(), GNUNET_TRANSPORT_TESTING_ConnectRequest::tct, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), and GNUNET_TRANSPORT_TESTING_start_peer().

262 {
264  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
265  char *p2_s;
266  /* Find PeerContext */
267  int no = 0;
268  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = NULL;
270 
271  p2 = find_peer_context (p->tth,
272  peer);
273  no = p->no;
274  if (NULL != p2)
275  GNUNET_asprintf (&p2_s,
276  "%u (`%s')",
277  p2->no,
278  GNUNET_i2s (&p2->id));
279  else
280  GNUNET_asprintf (&p2_s,
281  "`%s'",
282  GNUNET_i2s (peer));
284  "Peers %s disconnected from peer %u (`%s')\n",
285  p2_s,
286  no,
287  GNUNET_i2s (&p->id));
288  GNUNET_free (p2_s);
289  /* notify about disconnect */
290  if (NULL != p->nd)
291  p->nd (p->cb_cls,
292  peer,
293  handler_cls);
294  if (NULL == p2)
295  return;
296  /* clear MQ, it is now invalid */
298  p2,
299  &set_mq,
300  NULL);
301  /* update set connected flags for all requests */
303  p2,
304  &clear_p1c,
305  NULL);
307  p,
308  &clear_p2c,
309  NULL);
310  /* resume connectivity requests as necessary */
311  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
312  {
313  if (GNUNET_NO == cc->connected)
314  continue;
315  if ( (GNUNET_YES != cc->p1_c) ||
316  (GNUNET_YES != cc->p2_c) )
317  {
318  cc->connected = GNUNET_NO;
319  /* start trying to connect */
320  if ( (NULL == cc->tct) &&
321  (NULL == cc->oh) )
323  cc);
324  if (NULL == cc->ats_sh)
326  &p2->id,
327  1);
328  }
329  }
330 }
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
static struct GNUNET_TRANSPORT_TESTING_PeerContext * find_peer_context(struct GNUNET_TRANSPORT_TESTING_Handle *tth, const struct GNUNET_PeerIdentity *peer)
struct GNUNET_PeerIdentity id
Peer identity.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.
Context for a single peer.
GNUNET_TRANSPORT_NotifyDisconnect nd
Notify disconnect callback.
static void clear_p2c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle by which we ask ATS to faciliate the connection.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
static void clear_p1c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
struct GNUNET_ATS_ConnectivitySuggestHandle * GNUNET_ATS_connectivity_suggest(struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
We would like to receive address suggestions for a peer.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
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:1273
int p1_c
Set if peer1 says the connection is up to peer2.
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
int connected
GNUNET_YES if both p1_c and p2_c are GNUNET_YES.
static void offer_hello(void *cls)
Offer the current HELLO of P2 to P1.
static void set_mq(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
#define GNUNET_YES
Definition: gnunet_common.h:80
void * cb_cls
Closure for the nc and nd callbacks.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
int p2_c
Set if peer2 says the connection is up to peer1.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_free(ptr)
Wrapper around free.
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 334 of file transport-testing.c.

References GNUNET_TRANSPORT_TESTING_PeerContext::cb_cls, GNUNET_assert, GNUNET_copy_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free_non_null, GNUNET_HELLO_get_id(), GNUNET_i2s(), GNUNET_OK, GNUNET_TRANSPORT_TESTING_PeerContext::hello, GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_PeerContext::no, p, GNUNET_TRANSPORT_TESTING_PeerContext::start_cb, and GNUNET_TRANSPORT_TESTING_PeerContext::start_cb_cls.

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), and GNUNET_TRANSPORT_TESTING_start_peer().

336 {
338  struct GNUNET_PeerIdentity hello_id;
339 
341  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) message,
342  &hello_id));
343  GNUNET_assert (0 == memcmp (&hello_id,
344  &p->id,
345  sizeof (hello_id)));
347  p->hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (message);
348 
349  if (NULL != p->start_cb)
350  {
352  "Peer %u (`%s') successfully started\n",
353  p->no,
354  GNUNET_i2s (&p->id));
355  p->start_cb (p->start_cb_cls);
356  p->start_cb = NULL;
357  }
358 }
int GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, struct GNUNET_PeerIdentity *peer)
Get the peer identity from a HELLO message.
Definition: hello.c:668
A HELLO message is used to exchange information about transports with other peers.
struct GNUNET_PeerIdentity id
Peer identity.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Context for a single peer.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
GNUNET_SCHEDULER_TaskCallback start_cb
Startup completed callback.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
The identity of the host (wraps the signing key of the peer).
struct GNUNET_HELLO_Message * hello
Peers HELLO Message.
void * cb_cls
Closure for the nc and nd callbacks.
void * start_cb_cls
Closure for start_cb.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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_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 375 of file transport-testing.c.

References GNUNET_TRANSPORT_TESTING_PeerContext::ats, GNUNET_MQ_MessageHandler::cb, GNUNET_TRANSPORT_TESTING_PeerContext::cb_cls, GNUNET_TRANSPORT_TESTING_PeerContext::cfg, get_hello(), GNUNET_TRANSPORT_TESTING_PeerContext::ghh, 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_free_non_null, 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(), GNUNET_TRANSPORT_TESTING_PeerContext::handlers, GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, nc, GNUNET_TRANSPORT_TESTING_PeerContext::nc, GNUNET_TRANSPORT_TESTING_PeerContext::nd, GNUNET_TRANSPORT_TESTING_PeerContext::no, notify_connect(), notify_disconnect(), p, GNUNET_TRANSPORT_TESTING_Handle::p_head, GNUNET_TRANSPORT_TESTING_Handle::p_tail, GNUNET_TRANSPORT_TESTING_PeerContext::peer, peer_id, GNUNET_TRANSPORT_TESTING_PeerContext::start_cb, start_cb(), GNUNET_TRANSPORT_TESTING_PeerContext::start_cb_cls, GNUNET_TRANSPORT_TESTING_PeerContext::th, GNUNET_TRANSPORT_TESTING_Handle::tl_system, GNUNET_TRANSPORT_TESTING_PeerContext::tmh, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

Referenced by connect_check_run().

384 {
385  char *emsg = NULL;
387  struct GNUNET_PeerIdentity dummy;
388  unsigned int i;
389 
390  if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
391  {
393  "File not found: `%s'\n",
394  cfgname);
395  return NULL;
396  }
397 
399  p->tth = tth;
400  p->nc = nc;
401  p->nd = nd;
402  if (NULL != handlers)
403  {
404  for (i=0;NULL != handlers[i].cb;i++) ;
405  p->handlers = GNUNET_new_array (i + 1,
406  struct GNUNET_MQ_MessageHandler);
408  handlers,
409  i * sizeof (struct GNUNET_MQ_MessageHandler));
410  }
411  if (NULL != cb_cls)
412  p->cb_cls = cb_cls;
413  else
414  p->cb_cls = p;
415  p->start_cb = start_cb;
416  if (NULL != start_cb_cls)
417  p->start_cb_cls = start_cb_cls;
418  else
419  p->start_cb_cls = p;
421  tth->p_tail,
422  p);
423 
424  /* Create configuration and call testing lib to modify it */
427  GNUNET_CONFIGURATION_load (p->cfg, cfgname));
428  if (GNUNET_SYSERR ==
430  p->cfg))
431  {
433  "Testing library failed to create unique configuration based on `%s'\n",
434  cfgname);
436  GNUNET_free (p);
437  return NULL;
438  }
439 
440  p->no = peer_id;
441  /* Configure peer with configuration */
443  p->cfg,
444  p->no,
445  NULL,
446  &emsg);
447  if (NULL == p->peer)
448  {
450  "Testing library failed to create unique configuration based on `%s': `%s'\n",
451  cfgname,
452  emsg);
454  GNUNET_free_non_null (emsg);
455  return NULL;
456  }
457  GNUNET_free_non_null (emsg);
459  {
461  "Testing library failed to create unique configuration based on `%s'\n",
462  cfgname);
464  return NULL;
465  }
466 
467  memset (&dummy,
468  '\0',
469  sizeof (dummy));
471  &p->id);
472  if (0 == memcmp (&dummy,
473  &p->id,
474  sizeof (struct GNUNET_PeerIdentity)))
475  {
477  "Testing library failed to obtain peer identity for peer %u\n",
478  p->no);
480  return NULL;
481  }
483  "Peer %u configured with identity `%s'\n",
484  p->no,
485  GNUNET_i2s_full (&p->id));
488  NULL,
489  handlers,
490  p,
493  NULL);
494  if ( (NULL == p->th) ||
495  (NULL == p->tmh) )
496  {
498  "Failed to connect to transport service for peer `%s': `%s'\n",
499  cfgname,
500  emsg);
502  return NULL;
503  }
505  if (NULL == p->ats)
506  {
508  "Failed to connect to ATS service for peer `%s': `%s'\n",
509  cfgname,
510  emsg);
512  return NULL;
513  }
516  &get_hello,
517  p);
518  GNUNET_assert (NULL != p->ghh);
519  return p;
520 }
int 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:669
static void * notify_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
static void get_hello(void *cb_cls, const struct GNUNET_MessageHeader *message)
static struct in_addr dummy
Target "dummy" address.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_CONFIGURATION_Handle * cfg
Peer's configuration.
int GNUNET_TESTING_peer_start(struct GNUNET_TESTING_Peer *peer)
Start the peer.
Definition: testing.c:1315
struct GNUNET_PeerIdentity id
Peer identity.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Context for a single peer.
GNUNET_TRANSPORT_NotifyDisconnect nd
Notify disconnect callback.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_NO
Definition: gnunet_common.h:81
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
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_MQ_MessageHandler * handlers
Receive callback.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
struct GNUNET_TESTING_System * tl_system
Testing library system handle.
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:1113
GNUNET_SCHEDULER_TaskCallback start_cb
Startup completed callback.
int GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
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:1134
static void notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
#define GNUNET_memcpy(dst, src, n)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
struct GNUNET_TRANSPORT_ManipulationHandle * tmh
Peer's transport service manipulation handle.
GNUNET_MQ_MessageCallback cb
Callback, called every time a new message of the specified type has been receied. ...
struct GNUNET_TRANSPORT_CoreHandle * th
Peer's transport service handle.
Message handler for a specific message type.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
struct GNUNET_TESTING_Peer * peer
Peer's testing handle.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
GNUNET_TRANSPORT_NotifyConnect nc
Notify connect callback.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_TRANSPORT_ManipulationHandle * GNUNET_TRANSPORT_manipulation_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the transport service.
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.
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:1292
static void start_cb(void *cls)
Function called once we have successfully launched a peer.
void * cb_cls
Closure for the nc and nd callbacks.
void GNUNET_TRANSPORT_TESTING_stop_peer(struct GNUNET_TRANSPORT_TESTING_PeerContext *p)
Shutdown the given peer.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Peer's transport get hello handle to retrieve peer's HELLO message.
void * start_cb_cls
Closure for start_cb.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_tail
tail DLL of peers
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_cbcallback to call when restarted
restart_cb_clscallback closure
Returns
GNUNET_OK in success otherwise GNUNET_SYSERR

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

References GNUNET_TRANSPORT_TESTING_PeerContext::ats, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_PeerContext::cfg, get_hello(), GNUNET_TRANSPORT_TESTING_PeerContext::ghh, 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(), GNUNET_TRANSPORT_TESTING_PeerContext::handlers, GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, GNUNET_TRANSPORT_TESTING_PeerContext::no, notify_connect(), notify_disconnect(), GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, GNUNET_TRANSPORT_TESTING_PeerContext::peer, GNUNET_TRANSPORT_TESTING_PeerContext::start_cb, GNUNET_TRANSPORT_TESTING_PeerContext::start_cb_cls, GNUNET_TRANSPORT_TESTING_PeerContext::th, GNUNET_TRANSPORT_TESTING_PeerContext::tmh, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

535 {
538 
539  /* shutdown */
541  "Stopping peer %u (`%s')\n",
542  p->no,
543  GNUNET_i2s (&p->id));
544  if (NULL != p->ghh)
545  {
547  p->ghh = NULL;
548  }
549  if (NULL != p->th)
550  {
552  p->th = NULL;
553  }
554  if (NULL != p->tmh)
555  {
557  p->tmh = NULL;
558  }
559  for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
560  {
561  ccn = cc->next;
562  if ( (cc->p1 == p) ||
563  (cc->p2 == p) )
565  }
566  if (NULL != p->ats)
567  {
569  p->ats = NULL;
570  }
571  if (GNUNET_SYSERR ==
573  {
575  "Failed to stop peer %u (`%s')\n",
576  p->no,
577  GNUNET_i2s (&p->id));
578  return GNUNET_SYSERR;
579  }
580 
581  sleep (5); // YUCK!
582 
584  "Restarting peer %u (`%s')\n",
585  p->no,
586  GNUNET_i2s (&p->id));
587  /* restart */
589  {
591  "Failed to restart peer %u (`%s')\n",
592  p->no,
593  GNUNET_i2s (&p->id));
594  return GNUNET_SYSERR;
595  }
596 
597  GNUNET_assert (NULL == p->start_cb);
598  p->start_cb = restart_cb;
599  p->start_cb_cls = restart_cb_cls;
600 
602  NULL,
603  p->handlers,
604  p,
607  NULL);
608  GNUNET_assert (NULL != p->th);
612  &get_hello,
613  p);
614  GNUNET_assert (NULL != p->ghh);
615  return GNUNET_OK;
616 }
Handle for a request to connect two peers.
static void * notify_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
static void get_hello(void *cb_cls, const struct GNUNET_MessageHeader *message)
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_CONFIGURATION_Handle * cfg
Peer's configuration.
int GNUNET_TESTING_peer_start(struct GNUNET_TESTING_Peer *peer)
Start the peer.
Definition: testing.c:1315
struct GNUNET_PeerIdentity id
Peer identity.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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_MQ_MessageHandler * handlers
Receive callback.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
int GNUNET_TESTING_peer_stop(struct GNUNET_TESTING_Peer *peer)
Stop the peer.
Definition: testing.c:1418
GNUNET_SCHEDULER_TaskCallback start_cb
Startup completed callback.
static void notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
struct GNUNET_TRANSPORT_ManipulationHandle * tmh
Peer's transport service manipulation handle.
struct GNUNET_TRANSPORT_CoreHandle * th
Peer's transport service handle.
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
struct GNUNET_TESTING_Peer * peer
Peer's testing handle.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
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 ...
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
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_TESTING_PeerContext * p1
Peer we want to connect.
void GNUNET_TRANSPORT_manipulation_disconnect(struct GNUNET_TRANSPORT_ManipulationHandle *handle)
Disconnect from the transport service.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Peer's transport get hello handle to retrieve peer's HELLO message.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
void * start_cb_cls
Closure for start_cb.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
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
pthe peer

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

References GNUNET_TRANSPORT_TESTING_PeerContext::ats, GNUNET_TRANSPORT_TESTING_Handle::cc_head, GNUNET_TRANSPORT_TESTING_PeerContext::cfg, GNUNET_TRANSPORT_TESTING_PeerContext::ghh, 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(), GNUNET_TRANSPORT_TESTING_PeerContext::handlers, GNUNET_TRANSPORT_TESTING_PeerContext::hello, GNUNET_TRANSPORT_TESTING_PeerContext::id, LOG, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, GNUNET_TRANSPORT_TESTING_PeerContext::no, GNUNET_TRANSPORT_TESTING_ConnectRequest::p1, GNUNET_TRANSPORT_TESTING_ConnectRequest::p2, GNUNET_TRANSPORT_TESTING_Handle::p_head, GNUNET_TRANSPORT_TESTING_Handle::p_tail, GNUNET_TRANSPORT_TESTING_PeerContext::peer, GNUNET_TRANSPORT_TESTING_PeerContext::th, GNUNET_TRANSPORT_TESTING_PeerContext::tmh, and GNUNET_TRANSPORT_TESTING_PeerContext::tth.

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

626 {
627  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
630 
631  for (cc = tth->cc_head; NULL != cc; cc = ccn)
632  {
633  ccn = cc->next;
634  if ( (cc->p1 == p) ||
635  (cc->p2 == p) )
637  }
638  if (NULL != p->ghh)
639  {
641  p->ghh = NULL;
642  }
643  if (NULL != p->tmh)
644  {
646  p->tmh = NULL;
647  }
648  if (NULL != p->th)
649  {
651  p->th = NULL;
652  }
653  if (NULL != p->peer)
654  {
655  if (GNUNET_OK !=
657  {
659  "Testing lib failed to stop peer %u (`%s')\n",
660  p->no,
661  GNUNET_i2s (&p->id));
662  }
664  p->peer = NULL;
665  }
666  if (NULL != p->ats)
667  {
669  p->ats = NULL;
670  }
671  if (NULL != p->hello)
672  {
673  GNUNET_free (p->hello);
674  p->hello = NULL;
675  }
676  if (NULL != p->cfg)
677  {
679  p->cfg = NULL;
680  }
681  if (NULL != p->handlers)
682  {
683  GNUNET_free (p->handlers);
684  p->handlers = NULL;
685  }
687  tth->p_tail,
688  p);
690  "Peer %u (`%s') stopped\n",
691  p->no,
692  GNUNET_i2s (&p->id));
693  GNUNET_free (p);
694 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_CONFIGURATION_Handle * cfg
Peer's configuration.
struct GNUNET_PeerIdentity id
Peer identity.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_MQ_MessageHandler * handlers
Receive callback.
#define LOG(kind,...)
unsigned int no
An unique number to identify the peer.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
int GNUNET_TESTING_peer_stop(struct GNUNET_TESTING_Peer *peer)
Stop the peer.
Definition: testing.c:1418
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GNUNET_TRANSPORT_ManipulationHandle * tmh
Peer's transport service manipulation handle.
struct GNUNET_TRANSPORT_CoreHandle * th
Peer's transport service handle.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
struct GNUNET_TESTING_Peer * peer
Peer's testing handle.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
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 ...
struct GNUNET_HELLO_Message * hello
Peers HELLO Message.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
void GNUNET_TRANSPORT_manipulation_disconnect(struct GNUNET_TRANSPORT_ManipulationHandle *handle)
Disconnect from the transport service.
struct GNUNET_TRANSPORT_HelloGetHandle * ghh
Peer's transport get hello handle to retrieve peer's HELLO message.
void GNUNET_TESTING_peer_destroy(struct GNUNET_TESTING_Peer *peer)
Destroy the peer.
Definition: testing.c:1511
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_tail
tail DLL of peers
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 702 of file transport-testing.c.

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

703 {
705 
706  cc->oh = NULL;
708  &offer_hello,
709  cc);
710 }
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
static void offer_hello(void *cls)
Offer the current HELLO of P2 to P1.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
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
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 762 of file transport-testing.c.

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

766 {
767  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
770 
771  ccn = NULL;
772  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
773  {
774  if ( (cc->p1 == p1) &&
775  (cc->p2 == p2) )
776  {
777  ccn = cc;
778  break;
779  }
780  }
781 
783  cc->p1 = p1;
784  cc->p2 = p2;
785  cc->cb = cb;
786  if (NULL != cls)
787  cc->cb_cls = cls;
788  else
789  cc->cb_cls = cc;
790  if (NULL != ccn)
791  {
792  cc->p1_c = ccn->p1_c;
793  cc->p2_c = ccn->p2_c;
794  cc->connected = ccn->connected;
795  }
797  tth->cc_tail,
798  cc);
800  cc);
802  &p2->id,
803  1);
805  "New connect request %p\n",
806  cc);
807  return cc;
808 }
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_PeerIdentity id
Peer identity.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle by which we ask ATS to faciliate the connection.
#define LOG(kind,...)
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
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:1273
int p1_c
Set if peer1 says the connection is up to peer2.
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
int connected
GNUNET_YES if both p1_c and p2_c are GNUNET_YES.
GNUNET_SCHEDULER_TaskCallback cb
Function to call upon completion.
static void offer_hello(void *cls)
Offer the current HELLO of P2 to P1.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
int p2_c
Set if peer2 says the connection is up to peer1.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_tail
head DLL of connect contexts
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 succesfully.

Cancel the request to connect two peers.

Parameters
tthtransport testing handle
cca connect request handle

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

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

820 {
821  struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
822 
824  "Canceling connect request!\n");
825  if (NULL != cc->tct)
826  {
828  cc->tct = NULL;
829  }
830  if (NULL != cc->oh)
831  {
833  cc->oh = NULL;
834  }
835  if (NULL != cc->ats_sh)
836  {
838  cc->ats_sh = NULL;
839  }
841  tth->cc_tail,
842  cc);
843  GNUNET_free (cc);
844 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle by which we ask ATS to faciliate the connection.
#define LOG(kind,...)
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
void GNUNET_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_tail
head DLL of connect contexts
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 853 of file transport-testing.c.

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_PeerContext::next, GNUNET_TRANSPORT_TESTING_ConnectRequest::next, p, GNUNET_TRANSPORT_TESTING_Handle::p_head, t, and GNUNET_TRANSPORT_TESTING_Handle::tl_system.

Referenced by GNUNET_TRANSPORT_TESTING_main_().

854 {
859 
860  if (NULL == tth)
861  return;
862  cc = tth->cc_head;
863  while (NULL != cc)
864  {
865  ct = cc->next;
867  "Developer forgot to cancel connect request!\n");
869  cc = ct;
870  }
871  p = tth->p_head;
872  while (NULL != p)
873  {
874  t = p->next;
876  "Developer forgot to stop peer!\n");
878  p = t;
879  }
881  GNUNET_YES);
882 
883  GNUNET_free (tth);
884 }
Handle for a request to connect two peers.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
Context for a single peer.
static struct GNUNET_SCHEDULER_Task * t
Main task.
#define LOG(kind,...)
struct GNUNET_TRANSPORT_TESTING_PeerContext * next
Next element in the DLL.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
struct GNUNET_TESTING_System * tl_system
Testing library system handle.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
void GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, int remove_paths)
Free system resources.
Definition: testing.c:527
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 ...
#define GNUNET_YES
Definition: gnunet_common.h:80
void GNUNET_TRANSPORT_TESTING_stop_peer(struct GNUNET_TRANSPORT_TESTING_PeerContext *p)
Shutdown the given peer.
#define GNUNET_free(ptr)
Wrapper around free.
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 893 of file transport-testing.c.

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

894 {
896 
898  tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
899  NULL,
900  NULL,
901  NULL);
902  if (NULL == tth->tl_system)
903  {
905  "Failed to initialize testing library!\n");
906  GNUNET_free (tth);
907  return NULL;
908  }
909  return tth;
910 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TESTING_System * tl_system
Testing library system handle.
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:449
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function: