GNUnet  0.19.3
transport-testing.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2006, 2009, 2015, 2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
27 #include "transport-testing.h"
28 
29 
30 #define LOG(kind, ...) GNUNET_log_from (kind, "transport-testing", __VA_ARGS__)
31 
32 
35  const struct GNUNET_PeerIdentity *peer)
36 {
38 
39  for (t = tth->p_head; NULL != t; t = t->next)
40  if (0 == memcmp (&t->id,
41  peer,
42  sizeof(struct GNUNET_PeerIdentity)))
43  return t;
44  return NULL;
45 }
46 
47 
56 void
59  *p1,
60  struct
62  *p2,
64  cb,
65  void *cb_cls)
66 {
67  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
70 
71  for (cc = tth->cc_head; NULL != cc; cc = ccn)
72  {
73  ccn = cc->next;
74  if ((cc->p1 == p1) &&
75  (cc->p2 == p2))
76  cb (cb_cls,
77  cc);
78  }
79 }
80 
81 
82 static void
83 set_p1c (void *cls,
85 {
86  int *found = cls;
87 
88  if (NULL != found)
89  *found = GNUNET_YES;
90  cx->p1_c = GNUNET_YES;
91 }
92 
93 
94 static void
95 set_mq (void *cls,
97 {
98  struct GNUNET_MQ_Handle *mq = cls;
99 
100  cx->mq = mq;
101 }
102 
103 
104 static void
105 set_p2c (void *cls,
107 {
108  int *found = cls;
109 
110  if (NULL != found)
111  *found = GNUNET_YES;
112  cx->p2_c = GNUNET_YES;
113 }
114 
115 
116 static void
117 clear_p1c (void *cls,
119 {
120  int *found = cls;
121 
122  if (NULL != found)
123  *found = GNUNET_YES;
124  cx->p1_c = GNUNET_NO;
125 }
126 
127 
128 static void
129 clear_p2c (void *cls,
131 {
132  int *found = cls;
133 
134  if (NULL != found)
135  *found = GNUNET_YES;
136  cx->p2_c = GNUNET_NO;
137 }
138 
139 
140 static void *
141 notify_connect (void *cls,
142  const struct GNUNET_PeerIdentity *peer,
143  struct GNUNET_MQ_Handle *mq)
144 {
146  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
147  char *p2_s;
151  int found;
152  void *ret;
153 
154  p2 = find_peer_context (p->tth,
155  peer);
156  if (NULL != p->nc)
157  ret = p->nc (p->cb_cls,
158  peer,
159  mq);
160  else
161  ret = NULL;
162 
163  if (NULL != p2)
164  GNUNET_asprintf (&p2_s,
165  "%u (`%s')",
166  p2->no,
167  GNUNET_i2s (&p2->id));
168  else
169  GNUNET_asprintf (&p2_s,
170  "`%s'",
171  GNUNET_i2s (peer));
173  "Peers %s connected to peer %u (`%s')\n",
174  p2_s,
175  p->no,
176  GNUNET_i2s (&p->id));
177  GNUNET_free (p2_s);
178  /* update flags in connecting contexts */
179  found = GNUNET_NO;
181  p2,
182  &set_p1c,
183  &found);
184  if (GNUNET_NO == found)
185  {
187  cc->p1 = p;
188  cc->p2 = p2;
189  cc->p1_c = GNUNET_YES;
191  tth->cc_tail,
192  cc);
193  }
194  found = GNUNET_NO;
196  p,
197  &set_p2c,
198  &found);
199  if (GNUNET_NO == found)
200  {
202  cc->p1 = p2;
203  cc->p2 = p;
204  cc->p1_c = GNUNET_YES;
206  tth->cc_tail,
207  cc);
208  }
210  p2,
211  &set_mq,
212  mq);
213  /* update set connected flag for all requests */
214  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
215  {
216  if (GNUNET_YES == cc->connected)
217  continue;
218  if ((GNUNET_YES == cc->p1_c) &&
219  (GNUNET_YES == cc->p2_c))
220  {
221  cc->connected = GNUNET_YES;
222  /* stop trying to connect */
223  if (NULL != cc->tct)
224  {
226  cc->tct = NULL;
227  }
228  if (NULL != cc->oh)
229  {
231  cc->oh = NULL;
232  }
233  if (NULL != cc->ats_sh)
234  {
236  cc->ats_sh = NULL;
237  }
238  }
239  }
240  /* then notify application */
241  for (cc = tth->cc_head; NULL != cc; cc = ccn)
242  {
243  ccn = cc->next;
244  if ((GNUNET_YES == cc->connected) &&
245  (NULL != cc->cb))
246  {
247  cc->cb (cc->cb_cls);
248  cc->cb = NULL; /* only notify once! */
249  }
250  }
251  return ret;
252 }
253 
254 
260 static void
261 offer_hello (void *cls);
262 
263 
264 static void
265 notify_disconnect (void *cls,
266  const struct GNUNET_PeerIdentity *peer,
267  void *handler_cls)
268 {
270  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
271  char *p2_s;
272  /* Find PeerContext */
273  int no = 0;
274  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = NULL;
276 
277  p2 = find_peer_context (p->tth,
278  peer);
279  no = p->no;
280  if (NULL != p2)
281  GNUNET_asprintf (&p2_s,
282  "%u (`%s')",
283  p2->no,
284  GNUNET_i2s (&p2->id));
285  else
286  GNUNET_asprintf (&p2_s,
287  "`%s'",
288  GNUNET_i2s (peer));
290  "Peers %s disconnected from peer %u (`%s')\n",
291  p2_s,
292  no,
293  GNUNET_i2s (&p->id));
294  GNUNET_free (p2_s);
295  /* notify about disconnect */
296  if (NULL != p->nd)
297  p->nd (p->cb_cls,
298  peer,
299  handler_cls);
300  if (NULL == p2)
301  return;
302  /* clear MQ, it is now invalid */
304  p2,
305  &set_mq,
306  NULL);
307  /* update set connected flags for all requests */
309  p2,
310  &clear_p1c,
311  NULL);
313  p,
314  &clear_p2c,
315  NULL);
316  /* resume connectivity requests as necessary */
317  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
318  {
319  if (GNUNET_NO == cc->connected)
320  continue;
321  if ((GNUNET_YES != cc->p1_c) ||
322  (GNUNET_YES != cc->p2_c))
323  {
324  cc->connected = GNUNET_NO;
325  /* start trying to connect */
326  if ((NULL == cc->tct) &&
327  (NULL == cc->oh))
329  cc);
330  if (NULL == cc->ats_sh)
332  &p2->id,
333  1);
334  }
335  }
336 }
337 
338 
339 static void
341  const struct GNUNET_MessageHeader *message)
342 {
344  struct GNUNET_PeerIdentity hello_id;
345 
347  GNUNET_HELLO_get_id ((const struct
348  GNUNET_HELLO_Message *) message,
349  &hello_id));
350  GNUNET_assert (0 == memcmp (&hello_id,
351  &p->id,
352  sizeof(hello_id)));
353  GNUNET_free (p->hello);
354  p->hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (message);
355 
356  if (NULL != p->start_cb)
357  {
359  "Peer %u (`%s') successfully started\n",
360  p->no,
361  GNUNET_i2s (&p->id));
362  p->start_cb (p->start_cb_cls);
363  p->start_cb = NULL;
364  }
365 }
366 
367 
384  const char *cfgname,
385  int peer_id,
386  const struct
390  void *cb_cls,
392  void *start_cb_cls)
393 {
394  char *emsg = NULL;
396  struct GNUNET_PeerIdentity dummy;
397  unsigned int i;
398 
399  if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
400  {
402  "File not found: `%s'\n",
403  cfgname);
404  return NULL;
405  }
406 
408  p->tth = tth;
409  p->nc = nc;
410  p->nd = nd;
411  if (NULL != handlers)
412  {
413  for (i = 0; NULL != handlers[i].cb; i++)
414  ;
415  p->handlers = GNUNET_new_array (i + 1,
416  struct GNUNET_MQ_MessageHandler);
417  GNUNET_memcpy (p->handlers,
418  handlers,
419  i * sizeof(struct GNUNET_MQ_MessageHandler));
420  }
421  if (NULL != cb_cls)
422  p->cb_cls = cb_cls;
423  else
424  p->cb_cls = p;
425  p->start_cb = start_cb;
426  if (NULL != start_cb_cls)
427  p->start_cb_cls = start_cb_cls;
428  else
429  p->start_cb_cls = p;
431  tth->p_tail,
432  p);
433 
434  /* Create configuration and call testing lib to modify it */
435  p->cfg = GNUNET_CONFIGURATION_create ();
437  GNUNET_CONFIGURATION_load (p->cfg, cfgname));
438  if (GNUNET_SYSERR ==
440  p->cfg))
441  {
443  "Testing library failed to create unique configuration based on `%s'\n",
444  cfgname);
446  GNUNET_free (p);
447  return NULL;
448  }
449 
450  p->no = peer_id;
451  /* Configure peer with configuration */
453  p->cfg,
454  p->no,
455  NULL,
456  &emsg);
457  if (NULL == p->peer)
458  {
460  "Testing library failed to create unique configuration based on `%s': `%s'\n",
461  cfgname,
462  emsg);
464  GNUNET_free (emsg);
465  return NULL;
466  }
467 
468  if (GNUNET_OK != GNUNET_TESTING_peer_start (p->peer))
469  {
471  "Testing library failed to create unique configuration based on `%s'\n",
472  cfgname);
474  return NULL;
475  }
476 
477  memset (&dummy,
478  '\0',
479  sizeof(dummy));
481  &p->id);
482  if (0 == memcmp (&dummy,
483  &p->id,
484  sizeof(struct GNUNET_PeerIdentity)))
485  {
487  "Testing library failed to obtain peer identity for peer %u\n",
488  p->no);
490  return NULL;
491  }
493  "Peer %u configured with identity `%s'\n",
494  p->no,
495  GNUNET_i2s_full (&p->id));
497  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
498  NULL,
499  handlers,
500  p,
503  NULL);
504  if ((NULL == p->th) ||
505  (NULL == p->tmh))
506  {
508  "Failed to connect to transport service for peer `%s': `%s'\n",
509  cfgname,
510  emsg);
512  GNUNET_free (emsg);
513  return NULL;
514  }
515  p->ats = GNUNET_ATS_connectivity_init (p->cfg);
516  if (NULL == p->ats)
517  {
519  "Failed to connect to ATS service for peer `%s': `%s'\n",
520  cfgname,
521  emsg);
523  GNUNET_free (emsg);
524  return NULL;
525  }
526  p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
528  &get_hello,
529  p);
530  GNUNET_assert (NULL != p->ghh);
531  return p;
532 }
533 
534 
543 int
547  void *restart_cb_cls)
548 {
551 
552  /* shutdown */
554  "Stopping peer %u (`%s')\n",
555  p->no,
556  GNUNET_i2s (&p->id));
557  if (NULL != p->ghh)
558  {
560  p->ghh = NULL;
561  }
562  if (NULL != p->th)
563  {
565  p->th = NULL;
566  }
567  if (NULL != p->tmh)
568  {
570  p->tmh = NULL;
571  }
572  for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
573  {
574  ccn = cc->next;
575  if ((cc->p1 == p) ||
576  (cc->p2 == p))
578  }
579  if (NULL != p->ats)
580  {
582  p->ats = NULL;
583  }
584  if (GNUNET_SYSERR ==
585  GNUNET_TESTING_peer_stop (p->peer))
586  {
588  "Failed to stop peer %u (`%s')\n",
589  p->no,
590  GNUNET_i2s (&p->id));
591  return GNUNET_SYSERR;
592  }
593 
594  sleep (5); // YUCK!
595 
597  "Restarting peer %u (`%s')\n",
598  p->no,
599  GNUNET_i2s (&p->id));
600  /* restart */
602  {
604  "Failed to restart peer %u (`%s')\n",
605  p->no,
606  GNUNET_i2s (&p->id));
607  return GNUNET_SYSERR;
608  }
609 
610  GNUNET_assert (NULL == p->start_cb);
611  p->start_cb = restart_cb;
612  p->start_cb_cls = restart_cb_cls;
613 
614  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
615  NULL,
616  p->handlers,
617  p,
620  NULL);
621  GNUNET_assert (NULL != p->th);
622  p->ats = GNUNET_ATS_connectivity_init (p->cfg);
623  p->ghh = GNUNET_TRANSPORT_hello_get (p->cfg,
625  &get_hello,
626  p);
627  GNUNET_assert (NULL != p->ghh);
628  return GNUNET_OK;
629 }
630 
631 
637 void
640 {
641  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
644 
645  for (cc = tth->cc_head; NULL != cc; cc = ccn)
646  {
647  ccn = cc->next;
648  if ((cc->p1 == p) ||
649  (cc->p2 == p))
651  }
652  if (NULL != p->ghh)
653  {
655  p->ghh = NULL;
656  }
657  if (NULL != p->tmh)
658  {
660  p->tmh = NULL;
661  }
662  if (NULL != p->th)
663  {
665  p->th = NULL;
666  }
667  if (NULL != p->peer)
668  {
669  if (GNUNET_OK !=
670  GNUNET_TESTING_peer_stop (p->peer))
671  {
673  "Testing lib failed to stop peer %u (`%s')\n",
674  p->no,
675  GNUNET_i2s (&p->id));
676  }
678  p->peer = NULL;
679  }
680  if (NULL != p->ats)
681  {
683  p->ats = NULL;
684  }
685  if (NULL != p->hello)
686  {
687  GNUNET_free (p->hello);
688  p->hello = NULL;
689  }
690  if (NULL != p->cfg)
691  {
693  p->cfg = NULL;
694  }
695  if (NULL != p->handlers)
696  {
697  GNUNET_free (p->handlers);
698  p->handlers = NULL;
699  }
701  tth->p_tail,
702  p);
704  "Peer %u (`%s') stopped\n",
705  p->no,
706  GNUNET_i2s (&p->id));
707  GNUNET_free (p);
708 }
709 
710 
715 static void
716 hello_offered (void *cls)
717 {
719 
720  cc->oh = NULL;
722  &offer_hello,
723  cc);
724 }
725 
726 
732 static void
733 offer_hello (void *cls)
734 {
736  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1 = cc->p1;
737  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = cc->p2;
738 
739  cc->tct = NULL;
740  {
741  char *p2_s = GNUNET_strdup (GNUNET_i2s (&p2->id));
742 
744  "Asking peer %u (`%s') to connect peer %u (`%s'), providing HELLO with %u bytes\n",
745  p1->no,
746  GNUNET_i2s (&p1->id),
747  p2->no,
748  p2_s,
749  GNUNET_HELLO_size (cc->p2->hello));
750  GNUNET_free (p2_s);
751  }
752 
753  if (NULL != cc->oh)
755  cc->oh =
757  (const struct
758  GNUNET_MessageHeader *) cc->p2->hello,
759  &hello_offered,
760  cc);
761 }
762 
763 
779  struct
782  void *cls)
783 {
784  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
787 
788  ccn = NULL;
789  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
790  {
791  if ((cc->p1 == p1) &&
792  (cc->p2 == p2))
793  {
794  ccn = cc;
795  break;
796  }
797  }
798 
800  cc->p1 = p1;
801  cc->p2 = p2;
802  cc->cb = cb;
803  if (NULL != cls)
804  cc->cb_cls = cls;
805  else
806  cc->cb_cls = cc;
807  if (NULL != ccn)
808  {
809  cc->p1_c = ccn->p1_c;
810  cc->p2_c = ccn->p2_c;
811  cc->connected = ccn->connected;
812  }
814  tth->cc_tail,
815  cc);
817  cc);
819  &p2->id,
820  1);
822  "New connect request %p\n",
823  cc);
824  return cc;
825 }
826 
827 
835 void
838  *cc)
839 {
840  struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
841 
843  "Canceling connect request!\n");
844  if (NULL != cc->tct)
845  {
847  cc->tct = NULL;
848  }
849  if (NULL != cc->oh)
850  {
852  cc->oh = NULL;
853  }
854  if (NULL != cc->ats_sh)
855  {
857  cc->ats_sh = NULL;
858  }
860  tth->cc_tail,
861  cc);
862  GNUNET_free (cc);
863 }
864 
865 
871 void
873 {
878 
879  if (NULL == tth)
880  return;
881  cc = tth->cc_head;
882  while (NULL != cc)
883  {
884  ct = cc->next;
886  "Developer forgot to cancel connect request!\n");
888  cc = ct;
889  }
890  p = tth->p_head;
891  while (NULL != p)
892  {
893  t = p->next;
895  "Developer forgot to stop peer!\n");
897  p = t;
898  }
900  GNUNET_YES);
901 
902  GNUNET_free (tth);
903 }
904 
905 
913 {
915 
917  tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
918  NULL,
919  NULL,
920  NULL);
921  if (NULL == tth->tl_system)
922  {
924  "Failed to initialize testing library!\n");
925  GNUNET_free (tth);
926  return NULL;
927  }
928  return tth;
929 }
930 
931 
932 /* end of transport-testing.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static struct GNUNET_SCHEDULER_Task * t
Main task.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
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.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
void GNUNET_ATS_connectivity_suggest_cancel(struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:481
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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:649
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:630
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1272
int GNUNET_TESTING_peer_stop(struct GNUNET_TESTING_Peer *peer)
Stop the peer.
Definition: testing.c:1485
struct GNUNET_TESTING_System * GNUNET_TESTING_system_create(const char *testdir, const char *trusted_ip, const char *hostname, const struct GNUNET_TESTING_SharedService *shared_services)
Create a system handle.
Definition: testing.c:477
struct GNUNET_TESTING_Peer * GNUNET_TESTING_peer_configure(struct GNUNET_TESTING_System *system, struct GNUNET_CONFIGURATION_Handle *cfg, uint32_t key_number, struct GNUNET_PeerIdentity *id, char **emsg)
Configure a GNUnet peer.
Definition: testing.c:1188
void GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, int remove_paths)
Free system resources.
Definition: testing.c:557
int GNUNET_TESTING_peer_start(struct GNUNET_TESTING_Peer *peer)
Start the peer.
Definition: testing.c:1381
int GNUNET_TESTING_configuration_create(struct GNUNET_TESTING_System *system, struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new configuration using the given configuration as a template; ports and paths will be modif...
Definition: testing.c:1167
void GNUNET_TESTING_peer_destroy(struct GNUNET_TESTING_Peer *peer)
Destroy the peer.
Definition: testing.c:1566
void GNUNET_TESTING_peer_get_identity(struct GNUNET_TESTING_Peer *peer, struct GNUNET_PeerIdentity *id)
Obtain the peer identity from a peer handle.
Definition: testing.c:1359
#define GNUNET_TIME_UNIT_SECONDS
One second.
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_TRANSPORT_offer_hello_cancel(struct GNUNET_TRANSPORT_OfferHelloHandle *ohh)
Cancel the request to transport to offer the HELLO message.
void *(* GNUNET_TRANSPORT_NotifyConnect)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Function called to notify transport users that another peer connected to us.
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_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.
void(* GNUNET_TRANSPORT_NotifyDisconnect)(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
Function called to notify transport users that another peer disconnected from us.
void GNUNET_TRANSPORT_hello_get_cancel(struct GNUNET_TRANSPORT_HelloGetHandle *ghh)
Stop receiving updates about changes to our HELLO message.
struct GNUNET_TRANSPORT_ManipulationHandle * GNUNET_TRANSPORT_manipulation_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the transport service.
void GNUNET_TRANSPORT_manipulation_disconnect(struct GNUNET_TRANSPORT_ManipulationHandle *handle)
Disconnect from the transport service.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
@ GNUNET_TRANSPORT_AC_ANY
Bitmask for "any" address.
A HELLO message is used to exchange information about transports with other peers.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_SCHEDULER_Task * next
This is a linked list.
Definition: scheduler.c:140
Handle for a request to connect two peers.
struct GNUNET_MQ_Handle * mq
Message queue for sending from p1 to p2.
int connected
GNUNET_YES if both p1_c and p2_c are GNUNET_YES.
struct GNUNET_TRANSPORT_OfferHelloHandle * oh
Handle by which we inform the peer about the HELLO of the other peer.
int p2_c
Set if peer2 says the connection is up to peer1.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
GNUNET_SCHEDULER_TaskCallback cb
Function to call upon completion.
struct GNUNET_ATS_ConnectivitySuggestHandle * ats_sh
Handle by which we ask ATS to facilitate the connection.
struct GNUNET_SCHEDULER_Task * tct
Task by which we accomplish the connection.
int p1_c
Set if peer1 says the connection is up to peer2.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
struct GNUNET_TESTING_System * tl_system
Testing library system handle.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_tail
tail DLL of peers
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_head
head DLL of connect contexts
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc_tail
head DLL of connect contexts
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
void * cb_cls
Closure for the nc and nd callbacks.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
unsigned int no
An unique number to identify the peer.
struct GNUNET_PeerIdentity id
Peer identity.
void * start_cb_cls
Closure for start_cb.
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
GNUNET_TRANSPORT_NotifyDisconnect nd
Notify disconnect callback.
struct GNUNET_HELLO_Message * hello
Peers HELLO Message.
struct GNUNET_CONFIGURATION_Handle * cfg
Peer's configuration.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
static void start_cb(void *cls)
Function called once we have successfully launched a 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.
static void clear_p2c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
static void set_mq(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
void GNUNET_TRANSPORT_TESTING_stop_peer(struct GNUNET_TRANSPORT_TESTING_PeerContext *p)
Shutdown the given 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.
static void get_hello(void *cb_cls, const struct GNUNET_MessageHeader *message)
static void clear_p1c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
static void set_p2c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
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 void set_p1c(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
static void * notify_connect(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
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.
#define LOG(kind,...)
static void hello_offered(void *cls)
Function called after the HELLO was passed to the transport service.
void GNUNET_TRANSPORT_TESTING_done(struct GNUNET_TRANSPORT_TESTING_Handle *tth)
Clean up the transport testing.
struct GNUNET_TRANSPORT_TESTING_Handle * GNUNET_TRANSPORT_TESTING_init()
Initialize the transport testing.
static void notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
static struct GNUNET_TRANSPORT_TESTING_PeerContext * find_peer_context(struct GNUNET_TRANSPORT_TESTING_Handle *tth, const struct GNUNET_PeerIdentity *peer)
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 ...
static void offer_hello(void *cls)
Offer the current HELLO of P2 to P1.
testing lib for transport service
void(* GNUNET_TRANSPORT_TESTING_ConnectContextCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
Function called on matching connect requests.