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 */