gnunet-service-testbed.h

Go to the documentation of this file.

/*
   This file is part of GNUnet.
   Copyright (C) 2008--2013 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
 */
 
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_core_service.h"
 
#include "testbed.h"
#include "testbed_api.h"
#include "testbed_api_operations.h"
#include "testbed_api_hosts.h"
#include "gnunet_testing_lib.h"
#include "gnunet-service-testbed_links.h"
 
 
#define LOG(kind, ...)                           \
  GNUNET_log (kind, __VA_ARGS__)
 
#define LOG_DEBUG(...)                          \
  LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 
#define LIST_GROW_STEP 10
 
 
struct Route
{
  uint32_t dest;
 
  uint32_t thru;
};
 
 
struct ForwardedOperationContext
{
  struct ForwardedOperationContext *next;
 
  struct ForwardedOperationContext *prev;
 
  struct OperationContext *opc;
 
  struct GNUNET_SERVICE_Client *client;
 
  void *cls;
 
  struct GNUNET_SCHEDULER_Task *timeout_task;
 
  uint64_t operation_id;
 
  enum OperationType type;
};
 
 
struct HostRegistration
{
  struct HostRegistration *next;
 
  struct HostRegistration *prev;
 
  GNUNET_TESTBED_HostRegistrationCompletion cb;
 
  void *cb_cls;
 
  struct GNUNET_TESTBED_Host *host;
};
 
 
struct LinkControllersContext
{
  struct GNUNET_SERVICE_Client *client;
 
  uint64_t operation_id;
};
 
 
struct Peer
{
  union
  {
    struct
    {
      struct GNUNET_TESTING_Peer *peer;
 
      struct GNUNET_CONFIGURATION_Handle *cfg;
 
      int is_running;
    } local;
 
    struct
    {
      struct Slave *slave;
 
      uint32_t remote_host_id;
    } remote;
  } details;
 
  int is_remote;
 
  uint32_t id;
 
  uint32_t reference_cnt;
 
  uint32_t destroy_flag;
};
 
 
struct Context
{
  struct GNUNET_SERVICE_Client *client;
 
  char *master_ip;
 
  struct GNUNET_TESTING_System *system;
 
  uint32_t host_id;
};
 
 
struct SharedService
{
  char *name;
 
  uint32_t num_shared;
 
  uint32_t num_sharing;
};
 
 
struct RegisteredHostContext;
 
 
struct ForwardedOverlayConnectContext
{
  struct ForwardedOverlayConnectContext *next;
 
  struct ForwardedOverlayConnectContext *prev;
 
  struct RegisteredHostContext *rhc;
 
  struct GNUNET_MessageHeader *orig_msg;
 
  struct GNUNET_SERVICE_Client *client;
 
  uint64_t operation_id;
 
  uint32_t peer1;
 
  uint32_t peer2;
 
  uint32_t peer2_host_id;
};
 
 
struct RegisteredHostContext
{
  struct GNUNET_TESTBED_Host *reg_host;
 
  struct GNUNET_TESTBED_Host *host;
 
  struct ForwardedOverlayConnectContext *focc_dll_head;
 
  struct ForwardedOverlayConnectContext *focc_dll_tail;
 
  enum RHCState
  {
    RHC_INIT = 0,
 
    RHC_DONE
  } state;
};
 
 
struct HandlerContext_ShutdownPeers
{
  unsigned int nslaves;
 
  int timeout;
};
 
 
extern struct GNUNET_CONFIGURATION_Handle *GST_config;
 
extern struct Context *GST_context;
 
extern struct ForwardedOperationContext *fopcq_head;
 
extern struct ForwardedOperationContext *fopcq_tail;
 
extern struct Peer **GST_peer_list;
 
extern struct GNUNET_TESTBED_Host **GST_host_list;
 
extern struct OperationQueue *GST_opq_openfds;
 
extern struct GNUNET_TIME_Relative GST_timeout;
 
extern unsigned int GST_peer_list_size;
 
extern unsigned int GST_num_local_peers;
 
extern unsigned int GST_host_list_size;
 
extern char *GST_stats_dir;
 
#define VALID_HOST_ID(id) \
  (((id) < GST_host_list_size) && (NULL != GST_host_list[id]))
 
#define VALID_PEER_ID(id) \
  (((id) < GST_peer_list_size) && (NULL != GST_peer_list[id]))
 
 
#define GST_array_grow_large_enough(ptr, size, accommodate_size) \
  do                                                                    \
  {                                                                     \
    unsigned int growth_size;                                           \
    GNUNET_assert (size <= accommodate_size);                            \
    growth_size = size;                                                 \
    while (growth_size <= accommodate_size)                             \
    growth_size += LIST_GROW_STEP;                                    \
    GNUNET_array_grow (ptr, size, growth_size);                         \
    GNUNET_assert (size > accommodate_size);                            \
  } while (0)
 
 
void
GST_destroy_peer (struct Peer *peer);
 
 
void
GST_destroy_peers (void);
 
 
struct Route *
GST_find_dest_route (uint32_t host_id);
 
 
void
handle_overlay_connect (void *cls,
                        const struct GNUNET_TESTBED_OverlayConnectMessage *msg);
 
 
void
GST_queue_host_registration (struct Slave *slave,
                             GNUNET_TESTBED_HostRegistrationCompletion cb,
                             void *cb_cls, struct GNUNET_TESTBED_Host *host);
 
 
void
GST_forwarded_operation_reply_relay (void *cls,
                                     const struct GNUNET_MessageHeader *msg);
 
 
void
GST_forwarded_operation_timeout (void *cls);
 
 
void
GST_clear_fopcq (void);
 
 
void
GST_send_operation_fail_msg (struct GNUNET_SERVICE_Client *client,
                             uint64_t operation_id,
                             const char *emsg);
 
 
void
GST_notify_client_disconnect_oc (struct GNUNET_SERVICE_Client *client);
 
 
void
GST_notify_client_disconnect_peers (struct GNUNET_SERVICE_Client *client);
 
 
void
GST_send_operation_success_msg (struct GNUNET_SERVICE_Client *client,
                                uint64_t operation_id);
 
 
int
check_remote_overlay_connect (void *cls,
                              const struct
                              GNUNET_TESTBED_RemoteOverlayConnectMessage *msg);
 
 
void
handle_remote_overlay_connect (void *cls,
                               const struct
                               GNUNET_TESTBED_RemoteOverlayConnectMessage *msg);
 
 
int
check_peer_create (void *cls,
                   const struct GNUNET_TESTBED_PeerCreateMessage *msg);
 
 
void
handle_peer_create (void *cls,
                    const struct GNUNET_TESTBED_PeerCreateMessage *msg);
 
 
void
handle_peer_destroy (void *cls,
                     const struct GNUNET_TESTBED_PeerDestroyMessage *msg);
 
 
void
handle_peer_start (void *cls,
                   const struct GNUNET_TESTBED_PeerStartMessage *msg);
 
 
void
handle_peer_stop (void *cls,
                  const struct GNUNET_TESTBED_PeerStopMessage *msg);
 
 
void
handle_peer_get_config (void *cls,
                        const struct
                        GNUNET_TESTBED_PeerGetConfigurationMessage *msg);
 
 
void
handle_shutdown_peers (void *cls,
                       const struct GNUNET_TESTBED_ShutdownPeersMessage *msg);
 
 
int
check_manage_peer_service (void *cls,
                           const struct
                           GNUNET_TESTBED_ManagePeerServiceMessage *msg);
 
 
void
handle_manage_peer_service (void *cls,
                            const struct
                            GNUNET_TESTBED_ManagePeerServiceMessage *msg);
 
 
int
check_peer_reconfigure (void *cls,
                        const struct
                        GNUNET_TESTBED_PeerReconfigureMessage *msg);
 
 
void
handle_peer_reconfigure (void *cls,
                         const struct
                         GNUNET_TESTBED_PeerReconfigureMessage *msg);
 
 
void
GST_free_mctxq (void);
 
 
void
GST_free_lcf (void);
 
 
void
GST_route_list_clear (void);
 
 
void
GST_process_next_focc (struct RegisteredHostContext *rhc);
 
 
void
GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc);
 
 
void
GST_free_occq (void);
 
 
void
GST_free_roccq (void);
 
 
void
GST_free_prcq (void);
 
 
void
GST_cache_init (unsigned int size);
 
 
void
GST_cache_clear (void);
 
 
const struct GNUNET_MessageHeader *
GST_cache_lookup_hello (const unsigned int peer_id);
 
 
void
GST_cache_add_hello (const unsigned int peer_id,
                     const struct GNUNET_MessageHeader *hello);
 
 
void
GST_stats_init (const struct GNUNET_CONFIGURATION_Handle *cfg);
 
 
void
GST_stats_destroy (void);
 
/* End of gnunet-service-testbed.h */