GNUnet 0.22.0
transport-testing2.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-testing2.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
56void
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
82static void
83set_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
94static void
95set_mq (void *cls,
97{
98 struct GNUNET_MQ_Handle *mq = cls;
99
100 cx->mq = mq;
101}
102
103
104static void
105set_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
116static void
117clear_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
128static void
129clear_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
140static void *
141notify_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->ah_sh)
229 {
231 cc->ah_sh = NULL;
232 }
233 }
234 }
235 /* then notify application */
236 for (cc = tth->cc_head; NULL != cc; cc = ccn)
237 {
238 ccn = cc->next;
239 if ((GNUNET_YES == cc->connected) &&
240 (NULL != cc->cb))
241 {
242 cc->cb (cc->cb_cls);
243 cc->cb = NULL; /* only notify once! */
244 }
245 }
246 return ret;
247}
248
249
250static void
252 const struct GNUNET_PeerIdentity *peer,
253 void *handler_cls)
254{
256 struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
257 char *p2_s;
258 /* Find PeerContext */
259 int no = 0;
260 struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = NULL;
262
263 p2 = find_peer_context (p->tth,
264 peer);
265 no = p->no;
266 if (NULL != p2)
267 GNUNET_asprintf (&p2_s,
268 "%u (`%s')",
269 p2->no,
270 GNUNET_i2s (&p2->id));
271 else
272 GNUNET_asprintf (&p2_s,
273 "`%s'",
274 GNUNET_i2s (peer));
276 "Peers %s disconnected from peer %u (`%s')\n",
277 p2_s,
278 no,
279 GNUNET_i2s (&p->id));
280 GNUNET_free (p2_s);
281 /* notify about disconnect */
282 if (NULL != p->nd)
283 p->nd (p->cb_cls,
284 peer,
285 handler_cls);
286 if (NULL == p2)
287 return;
288 /* clear MQ, it is now invalid */
290 p2,
291 &set_mq,
292 NULL);
293 /* update set connected flags for all requests */
295 p2,
296 &clear_p1c,
297 NULL);
299 p,
300 &clear_p2c,
301 NULL);
302 /* resume connectivity requests as necessary */
303 for (cc = tth->cc_head; NULL != cc; cc = cc->next)
304 {
305 if (GNUNET_NO == cc->connected)
306 continue;
307 if ((GNUNET_YES != cc->p1_c) ||
308 (GNUNET_YES != cc->p2_c))
309 {
310 cc->connected = GNUNET_NO;
311 /* start trying to connect */
312 if (NULL == cc->ah_sh)
314 &p2->id,
317 }
318 }
319}
320
321
322static void
323retrieve_hello (void *cls);
324
325static void
327 const struct GNUNET_PEERSTORE_Record *record,
328 const char *emsg)
329{
331 if (NULL == record)
332 {
333 p->pic = NULL;
334 if (NULL != p->start_cb)
336 return;
337 }
338 // Check record type et al?
339 p->hello_size = record->value_size;
340 p->hello = GNUNET_malloc (p->hello_size);
341 memcpy (p->hello, record->value, p->hello_size);
342 p->hello[p->hello_size - 1] = '\0';
343
345 p->pic = NULL;
346 if (NULL != p->start_cb)
347 {
349 "Peer %u (`%s') successfully started\n",
350 p->no,
351 GNUNET_i2s (&p->id));
352 p->start_cb (p->start_cb_cls);
353 p->start_cb = NULL;
354 }
355}
356
357
358static void
359retrieve_hello (void *cls)
360{
362 p->rh_task = NULL;
364 "transport",
365 &p->id,
368 p);
369
370}
371
372
376 const char *cfgname,
377 int peer_id,
378 const struct
382 void *cb_cls,
384 void *start_cb_cls)
385{
386 char *emsg = NULL;
389 unsigned int i;
390
391 if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
392 {
394 "File not found: `%s'\n",
395 cfgname);
396 return NULL;
397 }
398
400 p->tth = tth;
401 p->nc = nc;
402 p->nd = nd;
403 if (NULL != handlers)
404 {
405 for (i = 0; NULL != handlers[i].cb; i++)
406 ;
407 p->handlers = GNUNET_new_array (i + 1,
409 GNUNET_memcpy (p->handlers,
410 handlers,
411 i * sizeof(struct GNUNET_MQ_MessageHandler));
412 }
413 if (NULL != cb_cls)
414 p->cb_cls = cb_cls;
415 else
416 p->cb_cls = p;
417 p->start_cb = start_cb;
418 if (NULL != start_cb_cls)
419 p->start_cb_cls = start_cb_cls;
420 else
421 p->start_cb_cls = p;
423 tth->p_tail,
424 p);
425
426 /* Create configuration and call testing lib to modify it */
429 GNUNET_CONFIGURATION_load (p->cfg, cfgname));
430 if (GNUNET_SYSERR ==
431 GNUNET_TESTING_configuration_create (tth->tl_system,
432 p->cfg))
433 {
435 "Testing library failed to create unique configuration based on `%s'\n",
436 cfgname);
438 GNUNET_free (p);
439 return NULL;
440 }
441
442 p->no = peer_id;
443 /* Configure peer with configuration */
444 p->peer = GNUNET_TESTING_peer_configure (tth->tl_system,
445 p->cfg,
446 p->no,
447 NULL,
448 &emsg);
449 if (NULL == p->peer)
450 {
452 "Testing library failed to create unique configuration based on `%s': `%s'\n",
453 cfgname,
454 emsg);
456 GNUNET_free (emsg);
457 return NULL;
458 }
459
460 if (GNUNET_OK != GNUNET_TESTING_peer_start (p->peer))
461 {
463 "Testing library failed to create unique configuration based on `%s'\n",
464 cfgname);
466 return NULL;
467 }
468
469 memset (&dummy,
470 '\0',
471 sizeof(dummy));
472 GNUNET_TESTING_peer_get_identity (p->peer,
473 &p->id);
474 if (0 == memcmp (&dummy,
475 &p->id,
476 sizeof(struct GNUNET_PeerIdentity)))
477 {
479 "Testing library failed to obtain peer identity for peer %u\n",
480 p->no);
482 return NULL;
483 }
485 "Peer %u configured with identity `%s'\n",
486 p->no,
487 GNUNET_i2s_full (&p->id));
489 NULL,
490 handlers,
491 p,
494 if (NULL == p->th)
495 {
497 "Failed to connect to transport service for peer `%s': `%s'\n",
498 cfgname,
499 emsg);
501 GNUNET_free (emsg);
502 return NULL;
503 }
505 if (NULL == p->ah)
506 {
508 "Failed to connect to TNG service for peer `%s': `%s'\n",
509 cfgname,
510 emsg);
512 GNUNET_free (emsg);
513 return NULL;
514 }
515 p->ph = GNUNET_PEERSTORE_connect (p->cfg);
516 // FIXME Error handling
518
519 return p;
520}
521
522
523int
527 void *restart_cb_cls)
528{
531
532 /* shutdown */
534 "Stopping peer %u (`%s')\n",
535 p->no,
536 GNUNET_i2s (&p->id));
537 if (NULL != p->pic)
538 {
540 p->pic = NULL;
541 }
542 if (NULL != p->th)
543 {
545 p->th = NULL;
546 }
547 for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
548 {
549 ccn = cc->next;
550 if ((cc->p1 == p) ||
551 (cc->p2 == p))
553 }
554 if (NULL != p->ah)
555 {
557 p->ah = NULL;
558 }
559 if (GNUNET_SYSERR ==
560 GNUNET_TESTING_peer_stop (p->peer))
561 {
563 "Failed to stop peer %u (`%s')\n",
564 p->no,
565 GNUNET_i2s (&p->id));
566 return GNUNET_SYSERR;
567 }
568
569 sleep (5); // YUCK!
570
572 "Restarting peer %u (`%s')\n",
573 p->no,
574 GNUNET_i2s (&p->id));
575 /* restart */
576 if (GNUNET_SYSERR == GNUNET_TESTING_peer_start (p->peer))
577 {
579 "Failed to restart peer %u (`%s')\n",
580 p->no,
581 GNUNET_i2s (&p->id));
582 return GNUNET_SYSERR;
583 }
584
585 GNUNET_assert (NULL == p->start_cb);
586 p->start_cb = restart_cb;
587 p->start_cb_cls = restart_cb_cls;
588
590 NULL,
591 p->handlers,
592 p,
595 GNUNET_assert (NULL != p->th);
598 "transport",
599 &p->id,
602 p);
603 GNUNET_assert (NULL != p->pic);
604 return GNUNET_OK;
605}
606
607
613void
616{
617 struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
620 /* shutdown */
622 "Stopping peer %u (`%s')\n",
623 p->no,
624 GNUNET_i2s (&p->id));
625
626 for (cc = tth->cc_head; NULL != cc; cc = ccn)
627 {
628 ccn = cc->next;
629 if ((cc->p1 == p) ||
630 (cc->p2 == p))
632 }
633 if (NULL != p->pic)
634 {
636 p->pic = NULL;
637 }
638 if (NULL != p->th)
639 {
641 p->th = NULL;
642 }
643 if (NULL != p->ah)
644 {
646 p->ah = NULL;
647 }
648 if (NULL != p->ph)
649 {
651 "Disconnecting from PEERSTORE service\n");
653 p->ph = NULL;
654 }
655
656 if (NULL != p->peer)
657 {
658 if (GNUNET_OK !=
659 GNUNET_TESTING_peer_stop (p->peer))
660 {
662 "Testing lib failed to stop peer %u (`%s')\n",
663 p->no,
664 GNUNET_i2s (&p->id));
665 }
666 GNUNET_TESTING_peer_destroy (p->peer);
667 p->peer = NULL;
668 }
669 if (NULL != p->hello)
670 {
671 GNUNET_free (p->hello);
672 p->hello = NULL;
673 }
674 if (NULL != p->cfg)
675 {
677 p->cfg = NULL;
678 }
679 if (NULL != p->handlers)
680 {
681 GNUNET_free (p->handlers);
682 p->handlers = NULL;
683 }
685 tth->p_tail,
686 p);
688 "Peer %u (`%s') stopped\n",
689 p->no,
690 GNUNET_i2s (&p->id));
691 if (NULL != p->rh_task)
692 GNUNET_SCHEDULER_cancel (p->rh_task);
693 p->rh_task = NULL;
694 GNUNET_free (p);
695}
696
697
703/*
704 static void
705 hello_offered (void *cls)
706 {
707 struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
708
709 cc->oh = NULL;
710 cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
711 &offer_hello,
712 cc);
713 }*/
714
715
731 struct
734 void *cls)
735{
736 struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
739
740 ccn = NULL;
741 for (cc = tth->cc_head; NULL != cc; cc = cc->next)
742 {
743 if ((cc->p1 == p1) &&
744 (cc->p2 == p2))
745 {
746 ccn = cc;
747 break;
748 }
749 }
750
752 cc->p1 = p1;
753 cc->p2 = p2;
754 cc->cb = cb;
755 if (NULL != cls)
756 cc->cb_cls = cls;
757 else
758 cc->cb_cls = cc;
759 if (NULL != ccn)
760 {
761 cc->p1_c = ccn->p1_c;
762 cc->p2_c = ccn->p2_c;
763 cc->connected = ccn->connected;
764 }
766 tth->cc_tail,
767 cc);
769 &p2->id,
773 "New connect request %p\n",
774 cc);
775 return cc;
776}
777
778
779void
782 *cc)
783{
784 struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
785
787 "Canceling connect request!\n");
788 if (NULL != cc->tct)
789 {
791 cc->tct = NULL;
792 }
793 if (NULL != cc->ah_sh)
794 {
796 cc->ah_sh = NULL;
797 }
799 tth->cc_tail,
800 cc);
801 GNUNET_free (cc);
802}
803
804
810void
812{
817
818 if (NULL == tth)
819 return;
820 cc = tth->cc_head;
821 while (NULL != cc)
822 {
823 ct = cc->next;
825 "Developer forgot to cancel connect request!\n");
827 cc = ct;
828 }
829 p = tth->p_head;
830 while (NULL != p)
831 {
832 t = p->next;
834 "Developer forgot to stop peer!\n");
836 p = t;
837 }
838 GNUNET_TESTING_system_destroy (tth->tl_system,
839 GNUNET_YES);
840
842}
843
844
852{
854
856 tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
857 NULL,
858 NULL,
859 NULL);
860 if (NULL == tth->tl_system)
861 {
863 "Failed to initialize testing library!\n");
864 GNUNET_free (tth);
865 return NULL;
866 }
867 return tth;
868}
869
870
871/* end of transport-testing.c */
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static int ret
Final status code.
Definition: gnunet-arm.c:93
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static struct GNUNET_NotificationContext * nc
Notification context for broadcasting to monitors.
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_TRANSPORT_ApplicationSuggestHandle * GNUNET_TRANSPORT_application_suggest(struct GNUNET_TRANSPORT_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_MQ_PriorityPreferences pk, struct GNUNET_BANDWIDTH_Value32NBO bw)
An application would like TRANSPORT to connect to a peer.
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.
void GNUNET_TRANSPORT_application_done(struct GNUNET_TRANSPORT_ApplicationHandle *ch)
Shutdown TRANSPORT application client.
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_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.
void GNUNET_TRANSPORT_application_suggest_cancel(struct GNUNET_TRANSPORT_ApplicationSuggestHandle *sh)
We no longer care about being connected to a peer.
struct GNUNET_TRANSPORT_ApplicationHandle * GNUNET_TRANSPORT_application_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the TRANSPORT application client handle.
void GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
Disconnect from the transport service.
#define GNUNET_BANDWIDTH_ZERO
Convenience definition to use for 0-bandwidth.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new 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:483
#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.
#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_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
@ GNUNET_MQ_PRIO_BEST_EFFORT
Best-effort traffic (e.g.
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iteration_start(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Iterate over peerstore entries.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the PEERSTORE service.
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
#define GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY
Key used for storing HELLOs in the peerstore.
void GNUNET_PEERSTORE_iteration_stop(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iteration.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979
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:1303
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Single PEERSTORE record.
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:139
Handle for a request to connect two peers.
int connected
GNUNET_YES if both p1_c and p2_c are GNUNET_YES.
struct GNUNET_MQ_Handle * mq
Message queue for sending from p1 to p2.
int p2_c
Set if peer2 says the connection is up to peer1.
struct GNUNET_TRANSPORT_ApplicationSuggestHandle * ah_sh
Handle by which we ask TNG to facilitate the connection.
GNUNET_SCHEDULER_TaskCallback cb
Function to call upon completion.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p2
Peer we want to connect.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p1
Peer we want to connect.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * next
Kept in a DLL.
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_TESTBED_System * tl_system
Testing library system handle.
struct GNUNET_TRANSPORT_TESTING_PeerContext * p_head
head DLL of peers
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
void * cb_cls
Closure for the nc and nd callbacks.
struct GNUNET_TESTING_Peer * peer
Peer's testing handle.
unsigned int no
An unique number to identify the peer.
struct GNUNET_TRANSPORT_ApplicationHandle * ah
Application handle.
struct GNUNET_PeerIdentity id
Peer identity.
void * start_cb_cls
Closure for start_cb.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
GNUNET_TRANSPORT_NotifyDisconnect nd
Notify disconnect callback.
static void start_cb(void *cls)
Function called once we have successfully launched a 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.
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.
static void hello_iter_cb(void *cb_cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
static void clear_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)
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)
struct GNUNET_TRANSPORT_TESTING_Handle * GNUNET_TRANSPORT_TESTING_init()
Initialize the transport testing.
static void retrieve_hello(void *cls)
static struct GNUNET_TRANSPORT_TESTING_PeerContext * find_peer_context(struct GNUNET_TRANSPORT_TESTING_Handle *tth, const struct GNUNET_PeerIdentity *peer)
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)
Function called after the HELLO was passed to the transport service.
#define LOG(kind,...)
void GNUNET_TRANSPORT_TESTING_done(struct GNUNET_TRANSPORT_TESTING_Handle *tth)
Clean up the transport testing.
static void notify_disconnect(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
void GNUNET_TRANSPORT_TESTING_connect_peers_cancel(struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
Cancel the request to connect two peers.
void(* GNUNET_TRANSPORT_TESTING_ConnectContextCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
Function called on matching connect requests.