transport-testing.h

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2006, 2009, 2015, 2016 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#ifndef TRANSPORT_TESTING_H
#define TRANSPORT_TESTING_H
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_hello_lib.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_hello_service.h"
#include "gnunet_transport_manipulation_service.h"
#include "gnunet_testing_lib.h"
 
 
/* ************* Basic functions for starting/stopping/connecting *********** */
 
struct GNUNET_TRANSPORT_TESTING_PeerContext;
 
struct GNUNET_TRANSPORT_TESTING_Handle;
 
 
struct GNUNET_TRANSPORT_TESTING_PeerContext
{
  struct GNUNET_TRANSPORT_TESTING_PeerContext *next;
 
  struct GNUNET_TRANSPORT_TESTING_PeerContext *prev;
 
  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
 
  struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_TRANSPORT_CoreHandle *th;
 
  struct GNUNET_TRANSPORT_ManipulationHandle *tmh;
 
  struct GNUNET_ATS_ConnectivityHandle *ats;
 
  struct GNUNET_TRANSPORT_HelloGetHandle *ghh;
 
  struct GNUNET_TESTING_Peer *peer;
 
  struct GNUNET_PeerIdentity id;
 
  struct GNUNET_OS_Process *arm_proc;
 
  struct GNUNET_MQ_MessageHandler *handlers;
 
  GNUNET_TRANSPORT_NotifyConnect nc;
 
  GNUNET_TRANSPORT_NotifyDisconnect nd;
 
  GNUNET_SCHEDULER_TaskCallback start_cb;
 
  struct GNUNET_HELLO_Message *hello;
 
  void *cb_cls;
 
  void *start_cb_cls;
 
  unsigned int no;
};
 
 
struct GNUNET_TRANSPORT_TESTING_ConnectRequest
{
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *next;
 
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *prev;
 
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1;
 
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2;
 
  struct GNUNET_SCHEDULER_Task *tct;
 
  struct GNUNET_ATS_ConnectivitySuggestHandle *ats_sh;
 
  struct GNUNET_TRANSPORT_OfferHelloHandle *oh;
 
  GNUNET_SCHEDULER_TaskCallback cb;
 
  void *cb_cls;
 
  struct GNUNET_MQ_Handle *mq;
 
  int p1_c;
 
  int p2_c;
 
  int connected;
};
 
 
struct GNUNET_TRANSPORT_TESTING_Handle
{
  struct GNUNET_TESTING_System *tl_system;
 
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc_head;
 
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc_tail;
 
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p_head;
 
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p_tail;
};
 
 
struct GNUNET_TRANSPORT_TESTING_Handle *
GNUNET_TRANSPORT_TESTING_init (void);
 
 
void
GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth);
 
 
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);
 
 
void
GNUNET_TRANSPORT_TESTING_stop_peer (
  struct GNUNET_TRANSPORT_TESTING_PeerContext *pc);
 
 
int
GNUNET_TRANSPORT_TESTING_restart_peer (
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p,
  GNUNET_SCHEDULER_TaskCallback restart_cb,
  void *restart_cb_cls);
 
 
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);
 
 
void
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc);
 
 
typedef void (*GNUNET_TRANSPORT_TESTING_ConnectContextCallback) (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc);
 
 
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);
 
 
/* ********************** high-level process functions *************** */
 
 
typedef void (*GNUNET_TRANSPORT_TESTING_ConnectContinuation) (
  void *cls,
  unsigned int num_peers,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *p[]);
 
 
struct GNUNET_TRANSPORT_TESTING_ConnectRequestList;
 
struct GNUNET_TRANSPORT_TESTING_InternalPeerContext;
 
 
GNUNET_NETWORK_STRUCT_BEGIN
struct GNUNET_TRANSPORT_TESTING_TestMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t num GNUNET_PACKED;
};
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);
 
 
typedef void (*GNUNET_TRANSPORT_TESTING_NotifyConnect) (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
  const struct GNUNET_PeerIdentity *other);
 
 
typedef void (*GNUNET_TRANSPORT_TESTING_NotifyDisconnect) (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
  const struct GNUNET_PeerIdentity *other);
 
 
struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext
{
  GNUNET_SCHEDULER_TaskCallback connect_continuation;
 
  void *connect_continuation_cls;
 
  const char *config_file;
 
  GNUNET_TRANSPORT_TESTING_ReceiveCallback rec;
 
  GNUNET_TRANSPORT_TESTING_NotifyConnect nc;
 
  GNUNET_TRANSPORT_TESTING_NotifyDisconnect nd;
 
  void *cls;
 
  GNUNET_SCHEDULER_TaskCallback shutdown_task;
 
  void *shutdown_task_cls;
 
  GNUNET_SCHEDULER_TaskCallback pre_connect_task;
 
  void *pre_connect_task_cls;
 
  struct GNUNET_TIME_Relative timeout;
 
  int bi_directional;
 
  /* ******* fields set by #GNUNET_TRANSPORT_TESTING_connect_check **** */
 
  unsigned int num_peers;
 
  char **cfg_files;
 
  struct GNUNET_TRANSPORT_TESTING_PeerContext **p;
 
  const char *test_plugin;
 
  const char *test_name;
 
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
 
  int global_ret;
 
  uint32_t send_num_gen;
 
  /* ******* internal state, clients should not mess with this **** */
 
  struct GNUNET_SCHEDULER_Task *timeout_task;
 
  struct GNUNET_SCHEDULER_Task *connect_task;
 
  unsigned int started;
 
  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl_head;
 
  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl_tail;
 
  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ip;
};
 
 
struct GNUNET_TRANSPORT_TESTING_PeerContext *
GNUNET_TRANSPORT_TESTING_find_peer (
  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc,
  const struct GNUNET_PeerIdentity *peer);
 
 
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[]);
 
 
typedef 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[]);
 
 
int
GNUNET_TRANSPORT_TESTING_main_ (const char *argv0,
                                const char *filename,
                                unsigned int num_peers,
                                GNUNET_TRANSPORT_TESTING_CheckCallback check,
                                void *check_cls);
 
 
#define GNUNET_TRANSPORT_TESTING_main(num_peers, check, check_cls) \
  GNUNET_TRANSPORT_TESTING_main_ (argv[0],                         \
                                  __FILE__,                        \
                                  num_peers,                       \
                                  check,                           \
                                  check_cls)
 
/* ***************** Convenience functions for sending ********* */
 
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);
 
 
#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE 12345
 
#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2 12346
 
 
struct GNUNET_TRANSPORT_TESTING_SendClosure
{
  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
 
  size_t (*get_size_cb) (unsigned int n);
 
  unsigned int num_messages;
 
  GNUNET_SCHEDULER_TaskCallback cont;
 
  void *cont_cls;
};
 
 
void
GNUNET_TRANSPORT_TESTING_simple_send (void *cls);
 
#define GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE 2600
 
void
GNUNET_TRANSPORT_TESTING_large_send (void *cls);
 
 
/* ********************** log-only convenience functions ************* */
 
 
void
GNUNET_TRANSPORT_TESTING_log_connect (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
  const struct GNUNET_PeerIdentity *other);
 
 
void
GNUNET_TRANSPORT_TESTING_log_disconnect (
  void *cls,
  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
  const struct GNUNET_PeerIdentity *other);
 
 
/* ********************** low-level filename functions *************** */
 
 
char *
GNUNET_TRANSPORT_TESTING_get_test_name (const char *file);
 
 
char *
GNUNET_TRANSPORT_TESTING_get_config_name (const char *file, int count);
 
 
char *
GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *executable,
                                               const char *testname);
 
 
char *
GNUNET_TRANSPORT_TESTING_get_test_source_name (const char *file);
 
#endif
/* end of transport_testing.h */