GNUnet  0.19.3
transport-testing2.h
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  */
20 
27 #ifndef TRANSPORT_TESTING_H
28 #define TRANSPORT_TESTING_H
29 #include "platform.h"
30 #include "gnunet_util_lib.h"
31 #include "gnunet_hello_lib.h"
36 #include "gnunet_testing_lib.h"
37 
38 
39 /* ************* Basic functions for starting/stopping/connecting *********** */
40 
45 
50 
51 
56 {
61 
66 
71 
76 
81 
86 
91 
96 
101 
105  char *hello;
106 
110  size_t hello_size;
111 
115  struct GNUNET_TESTING_Peer *peer;
116 
120  struct GNUNET_PeerIdentity id;
121 
125  struct GNUNET_OS_Process *arm_proc;
126 
131 
136 
141 
146 
151 
155  void *cb_cls;
156 
160  void *start_cb_cls;
161 
165  unsigned int no;
166 };
167 
168 
173 {
178 
183 
188 
193 
197  struct GNUNET_SCHEDULER_Task *tct;
198 
203 
208 
212  void *cb_cls;
213 
217  struct GNUNET_MQ_Handle *mq;
218 
222  int p1_c;
223 
227  int p2_c;
228 
232  int connected;
233 };
234 
235 
240 {
245 
250 
255 
260 
265 };
266 
267 
275 
276 
282 void
284 
285 
303  const char *cfgname,
304  int peer_id,
305  const struct GNUNET_MQ_MessageHandler *handlers,
308  void *cb_cls,
310  void *start_cb_cls);
311 
312 
318 void
321 
322 
331 int
335  void *restart_cb_cls);
336 
337 
355  void *cls);
356 
357 
365 void
368 
369 
377  void *cls,
379 
380 
389 void
394  void *cb_cls);
395 
396 
397 /* ********************** high-level process functions *************** */
398 
399 
409  void *cls,
410  unsigned int num_peers,
412 
413 
418 
423 
424 
427 {
432 
436  uint32_t num GNUNET_PACKED;
437 };
438 
440 {
445 
450 
454  uint32_t num GNUNET_PACKED;
455 };
456 
458 
459 
469  void *cls,
471  const struct GNUNET_PeerIdentity *sender,
472  const struct GNUNET_TRANSPORT_TESTING_TestMessage *message);
473 
474 
484  void *cls,
486  const struct GNUNET_PeerIdentity *other);
487 
488 
498  void *cls,
500  const struct GNUNET_PeerIdentity *other);
501 
502 
508 {
513 
518 
523  const char *config_file;
524 
529 
534 
539 
543  void *cls;
544 
549 
553  void *shutdown_task_cls;
554 
562 
566  void *pre_connect_task_cls;
567 
572 
576  int bi_directional;
577 
578  /* ******* fields set by #GNUNET_TRANSPORT_TESTING_connect_check **** */
579 
583  unsigned int num_peers;
584 
588  char **cfg_files;
589 
594 
598  const char *test_plugin;
599 
603  const char *test_name;
604 
608  const struct GNUNET_CONFIGURATION_Handle *cfg;
609 
614 
619  int global_ret;
620 
627  uint32_t send_num_gen;
628 
629  /* ******* internal state, clients should not mess with this **** */
630 
635 
640 
644  unsigned int started;
645 
650 
655 
660 };
661 
662 
673  const struct GNUNET_PeerIdentity *peer);
674 
675 
692 int
694  void *cls,
695  struct GNUNET_TRANSPORT_TESTING_Handle *tth_,
696  const char *test_plugin_,
697  const char *test_name_,
698  unsigned int num_peers,
699  char *cfg_files[]);
700 
701 
715  void *cls,
716  struct GNUNET_TRANSPORT_TESTING_Handle *tth_,
717  const char *test_plugin_,
718  const char *test_name_,
719  unsigned int num_peers,
720  char *cfg_files[]);
721 
722 
733 int
734 GNUNET_TRANSPORT_TESTING_main_ (const char *argv0,
735  const char *filename,
736  unsigned int num_peers,
738  void *check_cls);
739 
740 
749 #define GNUNET_TRANSPORT_TESTING_main(num_peers, check, check_cls) \
750  GNUNET_TRANSPORT_TESTING_main_ (argv[0], \
751  __FILE__, \
752  num_peers, \
753  check, \
754  check_cls)
755 
756 /* ***************** Convenience functions for sending ********* */
757 
775 int
779  uint16_t mtype,
780  uint16_t msize,
781  uint32_t num,
783  void *cont_cls);
784 
785 
789 #define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE 12345
790 
794 #define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2 12346
795 
799 #define GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE 12347
800 
807 {
812 
818  size_t (*get_size_cb) (unsigned int n);
819 
824  unsigned int num_messages;
825 
830 
834  void *cont_cls;
835 };
836 
837 
846 void
848 
854 #define GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE 2600
855 
864 void
866 
867 
868 /* ********************** log-only convenience functions ************* */
869 
870 
878 void
880  void *cls,
882  const struct GNUNET_PeerIdentity *other);
883 
884 
892 void
894  void *cls,
896  const struct GNUNET_PeerIdentity *other);
897 
898 
899 /* ********************** low-level filename functions *************** */
900 
901 
909 char *
910 GNUNET_TRANSPORT_TESTING_get_test_name (const char *file);
911 
912 
921 char *
922 GNUNET_TRANSPORT_TESTING_get_config_name (const char *file, int count);
923 
924 
931 char *
932 GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *executable,
933  const char *testname);
934 
935 
943 char *
945 
946 #endif
947 /* end of transport_testing.h */
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static unsigned int num_peers
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static char * filename
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
static struct GNUNET_PEERINFO_NotifyContext * nc
Iterator context.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
Helper library for handling HELLOs.
API to the peerstore service.
Convenience API for writing testcases for GNUnet.
Bandwidth allocation API for applications to interact with.
API of the transport service towards the CORE service (TNG version)
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_NotifyDisconnect)(void *cls, const struct GNUNET_PeerIdentity *peer, void *handler_cls)
Function called to notify transport users that another peer disconnected from us.
#define GNUNET_NETWORK_STRUCT_BEGIN
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32.
#define GNUNET_NETWORK_STRUCT_END
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;.
#define GNUNET_PACKED
gcc-ism to get packed structs.
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:330
Handle to the ATS subsystem for connectivity management.
Handle for ATS address suggestion requests.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
Handle to the PEERSTORE service.
Definition: peerstore_api.c:41
Context for a iterate request.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle for a GNUnet peer controlled by testing.
Definition: testing.c:195
Handle for a system on which GNUnet peers are executed; a system is used for reserving unique paths a...
Definition: testing.c:122
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for relative time used by GNUnet, in microseconds.
Handle to the TRANSPORT subsystem for application management.
Handle for the transport service (includes all of the state for the transport service).
Closure that must be passed to GNUNET_TRANSPORT_TESTING_connect_check.
struct GNUNET_SCHEDULER_Task * timeout_task
Task run on timeout.
const char * test_plugin
Name of the plugin.
GNUNET_TRANSPORT_TESTING_NotifyConnect nc
Notify connect argument to give for peers we start.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Main testing handle.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration object for the testcase.
unsigned int num_peers
Number of peers involved in the test.
int global_ret
Result from the main function, set to GNUNET_OK on success.
struct GNUNET_TRANSPORT_TESTING_ConnectRequestList * crl_tail
DLL of active connect requests.
const char * test_name
Name of the testcase.
GNUNET_SCHEDULER_TaskCallback shutdown_task
Custom task to run on shutdown.
GNUNET_TRANSPORT_TESTING_ReceiveCallback rec
Receiver argument to give for peers we start.
GNUNET_SCHEDULER_TaskCallback connect_continuation
How should we continue after the connect?
GNUNET_TRANSPORT_TESTING_NotifyDisconnect nd
Notify disconnect argument to give for peers we start.
GNUNET_SCHEDULER_TaskCallback pre_connect_task
Custom task to run after peers were started but before we try to connect them.
struct GNUNET_TRANSPORT_TESTING_ConnectRequestList * crl_head
DLL of active connect requests.
void * connect_continuation_cls
Closure for connect_continuation.
void * cls
Closure for rec, nc and nd.
struct GNUNET_SCHEDULER_Task * connect_task
Task run to connect peers.
void * pre_connect_task_cls
Closure for shutdown_task.
int bi_directional
Should we try to create connections in both directions?
unsigned int started
Number of peers that have been started.
const char * config_file
Which configuration file should we pass to the GNUNET_PROGRAM_run() of the testcase?
char ** cfg_files
Configuration files we have, array with num_peers entries.
struct GNUNET_TRANSPORT_TESTING_PeerContext ** p
Array with num_peers entries.
struct GNUNET_TIME_Relative timeout
When should the testcase time out?
uint32_t send_num_gen
Generator for the num field in test messages.
void * shutdown_task_cls
Closure for shutdown_task.
struct GNUNET_TRANSPORT_TESTING_InternalPeerContext * ip
Array with num_peers entries.
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.
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.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * prev
Kept in a DLL.
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
struct GNUNET_MQ_MessageHandler * handlers
Receive callback.
void * cb_cls
Closure for the nc and nd callbacks.
struct GNUNET_TESTING_Peer * peer
Peer's testing handle.
struct GNUNET_PEERSTORE_Handle * ph
Peer's PEERSTORE Handle.
struct GNUNET_SCHEDULER_Task * rh_task
Hello get task.
struct GNUNET_TRANSPORT_TESTING_Handle * tth
Transport testing handle this peer belongs to.
struct GNUNET_PEERSTORE_IterateContext * pic
Peer's transport get hello handle to retrieve peer's HELLO message.
struct GNUNET_TRANSPORT_TESTING_PeerContext * prev
Previous element in the DLL.
GNUNET_SCHEDULER_TaskCallback start_cb
Startup completed callback.
unsigned int no
An unique number to identify the peer.
struct GNUNET_TRANSPORT_ApplicationHandle * ah
Application handle.
GNUNET_TRANSPORT_NotifyConnect nc
Notify connect callback.
struct GNUNET_PeerIdentity id
Peer identity.
void * start_cb_cls
Closure for start_cb.
struct GNUNET_ATS_ConnectivityHandle * ats
Peer's ATS handle.
struct GNUNET_OS_Process * arm_proc
Handle for the peer's ARM process.
struct GNUNET_TRANSPORT_TESTING_PeerContext * next
Next element in the DLL.
struct GNUNET_TRANSPORT_CoreHandle * th
Peer's transport service handle.
GNUNET_TRANSPORT_NotifyDisconnect nd
Notify disconnect callback.
struct GNUNET_CONFIGURATION_Handle * cfg
Peer's configuration.
uint32_t num
Monotonically increasing counter throughout the test.
struct GNUNET_TIME_AbsoluteNBO time_send
Time this message was send via transport api.
struct GNUNET_MessageHeader header
Type is (usually) GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE.
Type of the closure argument to pass to GNUNET_TRANSPORT_TESTING_simple_send() and GNUNET_TRANSPORT_T...
unsigned int num_messages
Number of messages to be transmitted in a loop.
struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext * ccc
Context for the transmission.
GNUNET_SCHEDULER_TaskCallback cont
Function to call after all transmissions, can be NULL.
size_t(* get_size_cb)(unsigned int n)
Function that returns the desired message size.
uint32_t num
Monotonically increasing counter throughout the test.
struct GNUNET_MessageHeader header
Type is (usually) GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE.
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_CheckCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_Handle *tth_, const char *test_plugin_, const char *test_name_, unsigned int num_peers, char *cfg_files[])
Main function of a testcase.
void(* GNUNET_TRANSPORT_TESTING_NotifyConnect)(void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
Function called to notify transport users that another peer connected to us.
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.
void(* GNUNET_TRANSPORT_TESTING_NotifyDisconnect)(void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
Function called to notify transport users that another peer disconnected from us.
void(* GNUNET_TRANSPORT_TESTING_ConnectContinuation)(void *cls, unsigned int num_peers, struct GNUNET_TRANSPORT_TESTING_PeerContext *p[])
Function called once the peers have been launched and connected by GNUNET_TRANSPORT_TESTING_connect_c...
void GNUNET_TRANSPORT_TESTING_large_send(void *cls)
Task that sends a large test message from the first peer to the second 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.
void GNUNET_TRANSPORT_TESTING_log_disconnect(void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
Log a disconnect event.
char * GNUNET_TRANSPORT_TESTING_get_test_source_name(const char *file)
Extracts the filename from an absolute file name and removes the extension.
void GNUNET_TRANSPORT_TESTING_simple_send(void *cls)
Task that sends a minimalistic test message from the first peer to the second peer.
void GNUNET_TRANSPORT_TESTING_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.
void GNUNET_TRANSPORT_TESTING_log_connect(void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *me, const struct GNUNET_PeerIdentity *other)
Log a connect event.
int GNUNET_TRANSPORT_TESTING_connect_check(void *cls, struct GNUNET_TRANSPORT_TESTING_Handle *tth_, const char *test_plugin_, const char *test_name_, unsigned int num_peers, char *cfg_files[])
Common implementation of the GNUNET_TRANSPORT_TESTING_CheckCallback.
char * GNUNET_TRANSPORT_TESTING_get_test_name(const char *file)
Extracts the test filename from an absolute file name and removes the extension.
int GNUNET_TRANSPORT_TESTING_send(struct GNUNET_TRANSPORT_TESTING_PeerContext *sender, struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, uint16_t mtype, uint16_t msize, uint32_t num, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Send a test message of type mtype and size msize from peer sender to peer receiver.
char * GNUNET_TRANSPORT_TESTING_get_config_name(const char *file, int count)
This function takes the filename (e.g.
void GNUNET_TRANSPORT_TESTING_stop_peer(struct GNUNET_TRANSPORT_TESTING_PeerContext *pc)
Shutdown the given peer.
GNUNET_NETWORK_STRUCT_END typedef void(* GNUNET_TRANSPORT_TESTING_ReceiveCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
Function called by the transport for each received message.
void(* GNUNET_TRANSPORT_TESTING_ConnectContextCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
Function called on matching connect requests.
struct GNUNET_TRANSPORT_TESTING_Handle * GNUNET_TRANSPORT_TESTING_init(void)
Initialize the transport testing.
struct GNUNET_TRANSPORT_TESTING_PeerContext * GNUNET_TRANSPORT_TESTING_find_peer(struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc, const struct GNUNET_PeerIdentity *peer)
Find peer by peer ID.
int GNUNET_TRANSPORT_TESTING_main_(const char *argv0, const char *filename, unsigned int num_peers, GNUNET_TRANSPORT_TESTING_CheckCallback check, void *check_cls)
Setup testcase.
struct GNUNET_TRANSPORT_TESTING_ConnectRequest * GNUNET_TRANSPORT_TESTING_connect_peers(struct GNUNET_TRANSPORT_TESTING_PeerContext *p1, struct GNUNET_TRANSPORT_TESTING_PeerContext *p2, GNUNET_SCHEDULER_TaskCallback cb, void *cls)
Connect the given peers and call the callback when both peers report the inbound connection.
void GNUNET_TRANSPORT_TESTING_done(struct GNUNET_TRANSPORT_TESTING_Handle *tth)
Clean up the transport testing.
void GNUNET_TRANSPORT_TESTING_connect_peers_cancel(struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
Cancel the request to connect two peers.
char * GNUNET_TRANSPORT_TESTING_get_test_plugin_name(const char *executable, const char *testname)
Extracts the plugin anme from an absolute file name and the test name.