gnunet-service-testbed.h File Reference

data structures shared amongst components of TESTBED service More...

#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"

Include dependency graph for gnunet-service-testbed.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Route
	A routing entry. More...
struct	ForwardedOperationContext
	Context information for operations forwarded to subcontrollers. More...
struct	HostRegistration
	A DLL of host registrations to be made. More...
struct	LinkControllersContext
	Context information used while linking controllers. More...
struct	Peer
	A peer. More...
struct	Context
	Context to hold data of peer. More...
struct	SharedService
	The structure for identifying a shared service. More...
struct	ForwardedOverlayConnectContext
	Context information to used during operations which forward the overlay connect message. More...
struct	RegisteredHostContext
	This context information will be created for each host that is registered at slave controllers during overlay connects. More...
struct	HandlerContext_ShutdownPeers
	Context data for GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS handler. More...

Macros
#define	LOG(kind, ...)    GNUNET_log (kind, __VA_ARGS__)
	Generic logging. More...
#define	LOG_DEBUG(...)    LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
	Debug logging. More...
#define	LIST_GROW_STEP   10
	By how much should the arrays lists grow. More...
#define	VALID_HOST_ID(id)    (((id) < GST_host_list_size) && (NULL != GST_host_list[id]))
	Condition to check if host id is valid. More...
#define	VALID_PEER_ID(id)    (((id) < GST_peer_list_size) && (NULL != GST_peer_list[id]))
	Condition to check if peer id is valid. More...
#define	GST_array_grow_large_enough(ptr, size, accommodate_size)
	Similar to GNUNET_array_grow(); however instead of calling GNUNET_array_grow() several times we call it only once. More...

Functions
void	GST_destroy_peer (struct Peer *peer)
	Function to destroy a peer. More...
void	GST_destroy_peers (void)
	Stops and destroys all peers. More...
struct Route *	GST_find_dest_route (uint32_t host_id)
	Finds the route with directly connected host as destination through which the destination host can be reached. More...
void	handle_overlay_connect (void *cls, const struct GNUNET_TESTBED_OverlayConnectMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages. More...
void	GST_queue_host_registration (struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
	Adds a host registration's request to a slave's registration queue. More...
void	GST_forwarded_operation_reply_relay (void *cls, const struct GNUNET_MessageHeader *msg)
	Callback to relay the reply msg of a forwarded operation back to the client. More...
void	GST_forwarded_operation_timeout (void *cls)
	Task to free resources when forwarded operation has been timed out. More...
void	GST_clear_fopcq (void)
	Clears the forwarded operations queue. More...
void	GST_send_operation_fail_msg (struct GNUNET_SERVICE_Client *client, uint64_t operation_id, const char *emsg)
	Send operation failure message to client. More...
void	GST_notify_client_disconnect_oc (struct GNUNET_SERVICE_Client *client)
	Notify OC subsystem that client disconnected. More...
void	GST_notify_client_disconnect_peers (struct GNUNET_SERVICE_Client *client)
	Notify peers subsystem that client disconnected. More...
void	GST_send_operation_success_msg (struct GNUNET_SERVICE_Client *client, uint64_t operation_id)
	Function to send generic operation success message to given client. More...
int	check_remote_overlay_connect (void *cls, const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages. More...
void	handle_remote_overlay_connect (void *cls, const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages. More...
int	check_peer_create (void *cls, const struct GNUNET_TESTBED_PeerCreateMessage *msg)
	Check #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages. More...
void	handle_peer_create (void *cls, const struct GNUNET_TESTBED_PeerCreateMessage *msg)
	Handler for #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages. More...
void	handle_peer_destroy (void *cls, const struct GNUNET_TESTBED_PeerDestroyMessage *msg)
	Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages. More...
void	handle_peer_start (void *cls, const struct GNUNET_TESTBED_PeerStartMessage *msg)
	Message handler for GNUNET_MESSAGE_TYPE_TESTBED_START_PEER messages. More...
void	handle_peer_stop (void *cls, const struct GNUNET_TESTBED_PeerStopMessage *msg)
	Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages. More...
void	handle_peer_get_config (void *cls, const struct GNUNET_TESTBED_PeerGetConfigurationMessage *msg)
	Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG messages. More...
void	handle_shutdown_peers (void *cls, const struct GNUNET_TESTBED_ShutdownPeersMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS messages. More...
int	check_manage_peer_service (void *cls, const struct GNUNET_TESTBED_ManagePeerServiceMessage *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE message. More...
void	handle_manage_peer_service (void *cls, const struct GNUNET_TESTBED_ManagePeerServiceMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE messages. More...
int	check_peer_reconfigure (void *cls, const struct GNUNET_TESTBED_PeerReconfigureMessage *msg)
	Check #GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER type messages. More...
void	handle_peer_reconfigure (void *cls, const struct GNUNET_TESTBED_PeerReconfigureMessage *msg)
	Handler for #GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER type messages. More...
void	GST_free_mctxq (void)
	Frees the ManageServiceContext queue. More...
void	GST_free_lcf (void)
	Cleans up the queue used for forwarding link controllers requests. More...
void	GST_route_list_clear (void)
	Cleans up the route list. More...
void	GST_process_next_focc (struct RegisteredHostContext *rhc)
	Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext. More...
void	GST_cleanup_focc (struct ForwardedOverlayConnectContext *focc)
	Cleans up ForwardedOverlayConnectContext. More...
void	GST_free_occq (void)
	Clears all pending overlay connect contexts in queue. More...
void	GST_free_roccq (void)
	Clears all pending remote overlay connect contexts in queue. More...
void	GST_free_prcq (void)
	Cleans up the Peer reconfigure context list. More...
void	GST_cache_init (unsigned int size)
	Initializes the cache. More...
void	GST_cache_clear (void)
	Clear cache. More...
const struct GNUNET_MessageHeader *	GST_cache_lookup_hello (const unsigned int peer_id)
	Looks up in the hello cache and returns the HELLO of the given peer. More...
void	GST_cache_add_hello (const unsigned int peer_id, const struct GNUNET_MessageHeader *hello)
	Caches the HELLO of the given peer. More...
void	GST_stats_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize logging CPU and IO statisticfs. More...
void	GST_stats_destroy (void)
	Shutdown the status calls module. More...

Variables
struct GNUNET_CONFIGURATION_Handle *	GST_config
	Our configuration. More...
struct Context *	GST_context
	The master context; generated with the first INIT message. More...
struct ForwardedOperationContext *	fopcq_head
	DLL head for forwarded operation contexts. More...
struct ForwardedOperationContext *	fopcq_tail
	DLL tail for forwarded operation contexts. More...
struct Peer **	GST_peer_list
	A list of peers we know about. More...
struct GNUNET_TESTBED_Host **	GST_host_list
	Array of hosts. More...
struct OperationQueue *	GST_opq_openfds
	Operation queue for open file descriptors. More...
struct GNUNET_TIME_Relative	GST_timeout
	Timeout for operations which may take some time. More...
unsigned int	GST_peer_list_size
	The size of the peer list. More...
unsigned int	GST_num_local_peers
	The current number of peers running locally under this controller. More...
unsigned int	GST_host_list_size
	The size of the host list. More...
char *	GST_stats_dir
	The directory where to store load statistics data. More...

Detailed Description

data structures shared amongst components of TESTBED service

Author

Sree Harsha Totakura

Definition in file gnunet-service-testbed.h.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log (kind, __VA_ARGS__)

Generic logging.

Definition at line 44 of file gnunet-service-testbed.h.

LOG_DEBUG

#define LOG_DEBUG

(

...

)

LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Debug logging.

Definition at line 50 of file gnunet-service-testbed.h.

LIST_GROW_STEP

#define LIST_GROW_STEP   10

By how much should the arrays lists grow.

Definition at line 56 of file gnunet-service-testbed.h.

VALID_HOST_ID

#define VALID_HOST_ID

(

id

)

(((id) < GST_host_list_size) && (NULL != GST_host_list[id]))

Condition to check if host id is valid.

Definition at line 473 of file gnunet-service-testbed.h.

VALID_PEER_ID

#define VALID_PEER_ID

(

id

)

(((id) < GST_peer_list_size) && (NULL != GST_peer_list[id]))

Condition to check if peer id is valid.

Definition at line 479 of file gnunet-service-testbed.h.

GST_array_grow_large_enough

#define GST_array_grow_large_enough	(		ptr,
			size,
			accommodate_size
	)

Value:

  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)

Similar to GNUNET_array_grow(); however instead of calling GNUNET_array_grow() several times we call it only once.

The array is also made to grow in steps of LIST_GROW_STEP.

Parameters

ptr	the array pointer to grow
size	the size of array
accommodate_size	the size which the array has to accommdate; after this call the array will be big enough to accommdate sizes up to accommodate_size

Definition at line 494 of file gnunet-service-testbed.h.

Function Documentation

GST_destroy_peer()

void GST_destroy_peer

(

struct Peer *

peer

)

Function to destroy a peer.

Parameters

peer	the peer structure to destroy

Definition at line 260 of file gnunet-service-testbed_peers.c.

{
  GNUNET_break (0 == peer->reference_cnt);
  if (GNUNET_YES == peer->is_remote)
  {
    peer_list_remove (peer);
    GNUNET_free (peer);
    return;
  }
  if (GNUNET_YES == peer->details.local.is_running)
  {
    GNUNET_TESTING_peer_stop (peer->details.local.peer);
    peer->details.local.is_running = GNUNET_NO;
  }
  GNUNET_TESTING_peer_destroy (peer->details.local.peer);
  GNUNET_CONFIGURATION_destroy (peer->details.local.cfg);
  peer_list_remove (peer);
  GNUNET_free (peer);
}

References GNUNET_break, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_NO, GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_stop(), GNUNET_YES, peer, and peer_list_remove().

Referenced by cleanup_mctx(), cleanup_occ(), cleanup_rocc(), handle_peer_destroy(), and peer_destroy_success_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_destroy_peers()

void GST_destroy_peers

(

void

)

Stops and destroys all peers.

Definition at line 1410 of file gnunet-service-testbed_peers.c.

{
  struct Peer *peer;
  unsigned int id;
 
  if (NULL == GST_peer_list)
    return;
  for (id = 0; id < GST_peer_list_size; id++)
  {
    peer = GST_peer_list[id];
    if (NULL == peer)
      continue;
    /* If destroy flag is set it means that this peer should have been
     * destroyed by a context which we destroy before */
    GNUNET_break (GNUNET_NO == peer->destroy_flag);
    /* counter should be zero as we free all contexts before */
    GNUNET_break (0 == peer->reference_cnt);
    if ((GNUNET_NO == peer->is_remote) &&
        (GNUNET_YES == peer->details.local.is_running))
      GNUNET_TESTING_peer_kill (peer->details.local.peer);
  }
  for (id = 0; id < GST_peer_list_size; id++)
  {
    peer = GST_peer_list[id];
    if (NULL == peer)
      continue;
    if (GNUNET_NO == peer->is_remote)
    {
      if (GNUNET_YES == peer->details.local.is_running)
        GNUNET_TESTING_peer_wait (peer->details.local.peer);
      GNUNET_TESTING_peer_destroy (peer->details.local.peer);
      GNUNET_CONFIGURATION_destroy (peer->details.local.cfg);
    }
    GNUNET_free (peer);
  }
  GNUNET_free (GST_peer_list);
  GST_peer_list = NULL;
  GST_peer_list_size = 0;
}

References GNUNET_break, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_NO, GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_kill(), GNUNET_TESTING_peer_wait(), GNUNET_YES, GST_peer_list, GST_peer_list_size, id, and peer.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_find_dest_route()

struct Route* GST_find_dest_route

(

uint32_t

host_id

)

Finds the route with directly connected host as destination through which the destination host can be reached.

Parameters

host_id

the id of the destination host

Returns

the route with directly connected destination host; NULL if no route is found

Definition at line 526 of file gnunet-service-testbed_links.c.

{
  struct Route *route;
 
  if (route_list_size <= host_id)
    return NULL;
  while (NULL != (route = route_list[host_id]))
  {
    if (route->thru == GST_context->host_id)
      break;
    host_id = route->thru;
  }
  return route;
}

References GST_context, Context::host_id, route_list, route_list_size, and Route::thru.

Referenced by forward_overlay_connect(), handle_link_controllers(), and handle_peer_create().

Here is the caller graph for this function:

handle_overlay_connect()

void handle_overlay_connect	(	void *	cls,
		const struct GNUNET_TESTBED_OverlayConnectMessage *	msg
	)

Handler for GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1531 of file gnunet-service-testbed_oc.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct Peer *peer;
  struct Peer *peer2;
  struct OverlayConnectContext *occ;
  struct Neighbour *p2n;
  uint64_t operation_id;
  uint32_t p1;
  uint32_t p2;
  uint32_t peer2_host_id;
 
  p1 = ntohl (msg->peer1);
  p2 = ntohl (msg->peer2);
  if (p1 == p2)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if (! VALID_PEER_ID (p1))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  peer = GST_peer_list[p1];
  operation_id = GNUNET_ntohll (msg->operation_id);
  LOG_DEBUG
    ("Received overlay connect for peers %u and %u with op id: 0x%llx\n",
    p1,
    p2,
    (unsigned long long) operation_id);
  peer2_host_id = ntohl (msg->peer2_host_id);
  if (GNUNET_YES == peer->is_remote)
  {
    if (! VALID_HOST_ID (peer2_host_id))
    {
      GNUNET_break (0);
      GNUNET_SERVICE_client_drop (client);
      return;
    }
    forward_overlay_connect (msg, client);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  p2n = NULL;
  occ = GNUNET_new (struct OverlayConnectContext);
  occ->type = OCC_TYPE_LOCAL;
  if (! VALID_PEER_ID (p2))         /* May be peer2 is on a another controller */
  {
    if (NULL == (p2n = GST_get_neighbour (peer2_host_id)))
    {
      if (! VALID_HOST_ID (peer2_host_id))
      {
        GNUNET_break (0);
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "0x%llx: Peer %u's host not in our neighbours list\n",
             (unsigned long long) operation_id, p2);
        GNUNET_SERVICE_client_drop (client);
        GNUNET_free (occ);
        return;
      }
      p2n = GST_create_neighbour (GST_host_list[peer2_host_id]);
    }
    occ->type = OCC_TYPE_REMOTE_LATERAL;
    occ->p2ctx.remote.p2n = p2n;
  }
  else if (GNUNET_YES == GST_peer_list[p2]->is_remote)
  {
    occ->type = OCC_TYPE_REMOTE_SLAVE;
    occ->p2ctx.remote.p2c = GST_peer_list[p2]->details.remote.slave->controller;
  }
  GNUNET_CONTAINER_DLL_insert_tail (occq_head,
                                    occq_tail,
                                    occ);
  occ->client = client;
  occ->other_peer_id = p2;
  GST_peer_list[p1]->reference_cnt++;
  occ->peer = GST_peer_list[p1];
  occ->op_id = operation_id;
  GNUNET_assert (NULL == occ->timeout_task);
  occ->timeout_task =
    GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                  &timeout_overlay_connect,
                                  occ);
  switch (occ->type)
  {
  case OCC_TYPE_REMOTE_LATERAL:
    GNUNET_asprintf (&occ->emsg,
                     "0x%llx: Timeout while acquiring connection to peer %u's "
                     "host: %u\n",
                     (unsigned long long) occ->op_id,
                     occ->other_peer_id,
                     peer2_host_id);
    occ->p2ctx.remote.ncn
      = GST_neighbour_get_connection (p2n,
                                      &p2_controller_connect_cb,
                                      occ);
    break;
  case OCC_TYPE_REMOTE_SLAVE:
    p2_controller_connect_cb (occ,
                              occ->p2ctx.remote.p2c);
    break;
  case OCC_TYPE_LOCAL:
    peer2 = GST_peer_list[occ->other_peer_id];
    peer2->reference_cnt++;
    GNUNET_TESTING_peer_get_identity (peer2->details.local.peer,
                                      &occ->other_peer_identity);
    GNUNET_asprintf (&occ->emsg,
                     "0x%llx: Timeout while connecting to CORE of peer with "
                     "id: %u",
                     (unsigned long long) occ->op_id,
                     occ->peer->id);
    LOG_DEBUG ("Peer %u has PID %s\n",
               occ->other_peer_id,
               GNUNET_i2s (&occ->other_peer_identity));
    {
      struct GNUNET_PeerIdentity lpid;
 
      GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
                                        &lpid);
      LOG_DEBUG ("Peer %u has PID %s\n",
                 p1,
                 GNUNET_i2s (&lpid));
    }
    occ->cgh_ch =
      GST_connection_pool_get_handle (occ->peer->id,
                                      occ->peer->details.local.cfg,
                                      GST_CONNECTIONPOOL_SERVICE_CORE,
                                      &occ_cache_get_handle_core_cb, occ,
                                      &occ->other_peer_identity,
                                      &overlay_connect_notify, occ);
    break;
  }
  GNUNET_SERVICE_client_continue (client);
}

References OverlayConnectContext::cgh_ch, OverlayConnectContext::client, Peer::details, OverlayConnectContext::emsg, forward_overlay_connect(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TESTING_peer_get_identity(), GNUNET_YES, GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_CORE, GST_create_neighbour(), GST_get_neighbour(), GST_host_list, GST_neighbour_get_connection(), GST_peer_list, GST_timeout, Peer::id, Peer::local, LOG, LOG_DEBUG, msg, RemotePeer2Context::ncn, occ_cache_get_handle_core_cb(), OCC_TYPE_LOCAL, OCC_TYPE_REMOTE_LATERAL, OCC_TYPE_REMOTE_SLAVE, occq_head, occq_tail, OverlayConnectContext::op_id, OverlayConnectContext::other_peer_id, OverlayConnectContext::other_peer_identity, overlay_connect_notify(), p2_controller_connect_cb(), RemotePeer2Context::p2c, OverlayConnectContext::p2ctx, RemotePeer2Context::p2n, OverlayConnectContext::peer, peer, Peer::reference_cnt, Peer::remote, OverlayConnectContext::remote, timeout_overlay_connect(), OverlayConnectContext::timeout_task, OverlayConnectContext::type, VALID_HOST_ID, and VALID_PEER_ID.

Here is the call graph for this function:

GST_queue_host_registration()

void GST_queue_host_registration	(	struct Slave *	slave,
		GNUNET_TESTBED_HostRegistrationCompletion	cb,
		void *	cb_cls,
		struct GNUNET_TESTBED_Host *	host
	)

Adds a host registration's request to a slave's registration queue.

Parameters

slave	the slave controller at which the given host has to be registered
cb	the host registration completion callback
cb_cls	the closure for the host registration completion callback
host	the host which has to be registered

Definition at line 247 of file gnunet-service-testbed.c.

{
  struct HostRegistration *hr;
  int call_register;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Queueing host registration for host %u at %u\n",
       GNUNET_TESTBED_host_get_id_ (host),
       GNUNET_TESTBED_host_get_id_ (GST_host_list[slave->host_id]));
  hr = GNUNET_new (struct HostRegistration);
  hr->cb = cb;
  hr->cb_cls = cb_cls;
  hr->host = host;
  call_register = (NULL == slave->hr_dll_head) ? GNUNET_YES : GNUNET_NO;
  GNUNET_CONTAINER_DLL_insert_tail (slave->hr_dll_head,
                                    slave->hr_dll_tail,
                                    hr);
  if (GNUNET_YES == call_register)
    register_next_host (slave);
}

References HostRegistration::cb, HostRegistration::cb_cls, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_TESTBED_host_get_id_(), GNUNET_YES, GST_host_list, HostRegistration::host, Slave::host_id, Slave::hr_dll_head, Slave::hr_dll_tail, LOG, and register_next_host().

Referenced by lcf_proc_task(), and register_host().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_forwarded_operation_reply_relay()

void GST_forwarded_operation_reply_relay	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

Callback to relay the reply msg of a forwarded operation back to the client.

Parameters

cls	ForwardedOperationContext
msg	the message to relay

Definition at line 279 of file gnunet-service-testbed.c.

{
  struct ForwardedOperationContext *fopc = cls;
  struct GNUNET_MQ_Envelope *env;
 
  LOG_DEBUG ("Relaying message with type: %u, size: %u\n",
             ntohs (msg->type),
             ntohs (msg->size));
  env = GNUNET_MQ_msg_copy (msg);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (fopc->client),
                  env);
  GNUNET_SCHEDULER_cancel (fopc->timeout_task);
  GNUNET_CONTAINER_DLL_remove (fopcq_head,
                               fopcq_tail,
                               fopc);
  GNUNET_free (fopc);
}

References ForwardedOperationContext::client, ForwardedOperationContext::cls, env, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_get_mq(), LOG_DEBUG, msg, GNUNET_MessageHeader::size, ForwardedOperationContext::timeout_task, and GNUNET_MessageHeader::type.

Referenced by forward_overlay_connect(), forwarded_overlay_connect_listener(), handle_manage_peer_service(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), peer_create_success_cb(), and peer_destroy_success_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_forwarded_operation_timeout()

void GST_forwarded_operation_timeout

(

void *

cls

)

Task to free resources when forwarded operation has been timed out.

Parameters

cls	the ForwardedOperationContext

Definition at line 300 of file gnunet-service-testbed.c.

{
  struct ForwardedOperationContext *fopc = cls;
 
  fopc->timeout_task = NULL;
  GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "A forwarded operation has timed out\n");
  GST_send_operation_fail_msg (fopc->client,
                               fopc->operation_id,
                               "A forwarded operation has timed out");
  GNUNET_CONTAINER_DLL_remove (fopcq_head,
                               fopcq_tail,
                               fopc);
  GNUNET_free (fopc);
}

References ForwardedOperationContext::client, ForwardedOperationContext::cls, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_TESTBED_forward_operation_msg_cancel_(), GST_send_operation_fail_msg(), LOG, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, and ForwardedOperationContext::timeout_task.

Referenced by client_disconnect_cb(), forward_overlay_connect(), forwarded_overlay_connect_timeout(), GST_notify_client_disconnect_oc(), GST_notify_client_disconnect_peers(), handle_manage_peer_service(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), and peer_create_forward_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_clear_fopcq()

void GST_clear_fopcq

(

void

)

Clears the forwarded operations queue.

Definition at line 677 of file gnunet-service-testbed.c.

{
  struct ForwardedOperationContext *fopc;
 
  while (NULL != (fopc = fopcq_head))
  {
    GNUNET_CONTAINER_DLL_remove (fopcq_head,
                                 fopcq_tail,
                                 fopc);
    GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
    if (NULL != fopc->timeout_task)
      GNUNET_SCHEDULER_cancel (fopc->timeout_task);
    switch (fopc->type)
    {
    case OP_PEER_CREATE:
      GNUNET_free (fopc->cls);
      break;
 
    case OP_SHUTDOWN_PEERS:
      {
        struct HandlerContext_ShutdownPeers *hc = fopc->cls;
 
        GNUNET_assert (0 < hc->nslaves);
        hc->nslaves--;
        if (0 == hc->nslaves)
          GNUNET_free (hc);
      }
      break;
 
    case OP_PEER_START:
    case OP_PEER_STOP:
    case OP_PEER_DESTROY:
    case OP_PEER_INFO:
    case OP_OVERLAY_CONNECT:
    case OP_LINK_CONTROLLERS:
    case OP_GET_SLAVE_CONFIG:
    case OP_MANAGE_SERVICE:
    case OP_PEER_RECONFIGURE:
      break;
 
    case OP_FORWARDED:
      GNUNET_assert (0);
    }
    ;
    GNUNET_free (fopc);
  }
}

References ForwardedOperationContext::cls, fopcq_head, fopcq_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_forward_operation_msg_cancel_(), HandlerContext_ShutdownPeers::nslaves, OP_FORWARDED, OP_GET_SLAVE_CONFIG, OP_LINK_CONTROLLERS, OP_MANAGE_SERVICE, OP_OVERLAY_CONNECT, OP_PEER_CREATE, OP_PEER_DESTROY, OP_PEER_INFO, OP_PEER_RECONFIGURE, OP_PEER_START, OP_PEER_STOP, OP_SHUTDOWN_PEERS, ForwardedOperationContext::opc, ForwardedOperationContext::timeout_task, and ForwardedOperationContext::type.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_send_operation_fail_msg()

void GST_send_operation_fail_msg	(	struct GNUNET_SERVICE_Client *	client,
		uint64_t	operation_id,
		const char *	emsg
	)

Send operation failure message to client.

Parameters

client	the client to which the failure message has to be sent to
operation_id	the id of the failed operation
emsg	the error message; can be NULL

Definition at line 125 of file gnunet-service-testbed.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_OperationFailureEventMessage *msg;
  uint16_t emsg_len;
 
  emsg_len = (NULL == emsg) ? 0 : strlen (emsg) + 1;
  env = GNUNET_MQ_msg_extra (msg,
                             emsg_len,
                             GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT);
  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
  msg->operation_id = GNUNET_htonll (operation_id);
  GNUNET_memcpy (&msg[1],
                 emsg,
                 emsg_len);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
}

References env, GNUNET_htonll(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_OPERATION_FINISHED, msg, and GNUNET_TESTBED_OperationFailureEventMessage::operation_id.

Referenced by GST_forwarded_operation_timeout(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_slave_get_config(), prc_stop_cb(), service_manage_result_cb(), shutdown_peers_reply_cb(), and timeout_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_notify_client_disconnect_oc()

void GST_notify_client_disconnect_oc

(

struct GNUNET_SERVICE_Client *

client

)

Notify OC subsystem that client disconnected.

Parameters

client

the client that disconnected

Definition at line 624 of file gnunet-service-testbed_oc.c.

{
  struct ForwardedOperationContext *fopc;
  struct ForwardedOperationContext *fopcn;
  struct OverlayConnectContext *occ;
  struct OverlayConnectContext *occn;
 
  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
  {
    fopcn = fopc->next;
    if (fopc->client == client)
    {
      GNUNET_SCHEDULER_cancel (fopc->timeout_task);
      GST_forwarded_operation_timeout (fopc);
    }
  }
  for (occ = occq_head; NULL != occ; occ = occn)
  {
    occn = occ->next;
    if (occ->client == client)
      cleanup_occ (occ);
  }
  // FIXME: implement clean up for client_keep replacements!
}

References cleanup_occ(), ForwardedOperationContext::client, OverlayConnectContext::client, fopcq_head, GNUNET_SCHEDULER_cancel(), GST_forwarded_operation_timeout(), ForwardedOperationContext::next, OverlayConnectContext::next, occq_head, and ForwardedOperationContext::timeout_task.

Referenced by client_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_notify_client_disconnect_peers()

void GST_notify_client_disconnect_peers

(

struct GNUNET_SERVICE_Client *

client

)

Notify peers subsystem that client disconnected.

Parameters

client

the client that disconnected

Definition at line 355 of file gnunet-service-testbed_peers.c.

{
  struct ForwardedOperationContext *fopc;
  struct ForwardedOperationContext *fopcn;
  struct ManageServiceContext *mctx;
  struct ManageServiceContext *mctxn;
  struct PeerReconfigureContext *prc;
  struct PeerReconfigureContext *prcn;
 
  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
  {
    fopcn = fopc->next;
    if (client == fopc->client)
    {
      if (OP_PEER_CREATE == fopc->type)
        GNUNET_free (fopc->cls);
      GNUNET_SCHEDULER_cancel (fopc->timeout_task);
      GST_forwarded_operation_timeout (fopc);
    }
  }
  for (mctx = mctx_head; NULL != mctx; mctx = mctxn)
  {
    mctxn = mctx->next;
    if (client == mctx->client)
      cleanup_mctx (mctx);
  }
  for (prc = prc_head; NULL != prc; prc = prcn)
  {
    prcn = prc->next;
    if (client == prc->client)
      cleanup_prc (prc);
  }
}

References cleanup_mctx(), cleanup_prc(), ForwardedOperationContext::client, ManageServiceContext::client, PeerReconfigureContext::client, ForwardedOperationContext::cls, fopcq_head, GNUNET_free, GNUNET_SCHEDULER_cancel(), GST_forwarded_operation_timeout(), mctx_head, ForwardedOperationContext::next, ManageServiceContext::next, PeerReconfigureContext::next, OP_PEER_CREATE, prc_head, ForwardedOperationContext::timeout_task, and ForwardedOperationContext::type.

Referenced by client_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_send_operation_success_msg()

void GST_send_operation_success_msg	(	struct GNUNET_SERVICE_Client *	client,
		uint64_t	operation_id
	)

Function to send generic operation success message to given client.

Parameters

client	the client to send the message to
operation_id	the id of the operation which was successful

Definition at line 154 of file gnunet-service-testbed.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg;
 
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS);
  msg->operation_id = GNUNET_htonll (operation_id);
  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
}

References env, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_OPERATION_FINISHED, msg, and GNUNET_TESTBED_GenericOperationSuccessEventMessage::operation_id.

Referenced by handle_peer_destroy(), handle_peer_reconfigure(), handle_shutdown_peers(), prc_stop_cb(), service_manage_result_cb(), and shutdown_peers_reply_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

check_remote_overlay_connect()

int check_remote_overlay_connect	(	void *	cls,
		const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *	msg
	)

Check GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 1870 of file gnunet-service-testbed_oc.c.

{
  uint32_t peer_id;
  uint16_t msize;
  uint16_t hsize;
 
  msize = ntohs (msg->header.size);
  if (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  hsize = ntohs (msg->hello->size);
  if ((sizeof(struct GNUNET_TESTBED_RemoteOverlayConnectMessage) + hsize) !=
      msize)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  peer_id = ntohl (msg->peer);
  if ((peer_id >= GST_peer_list_size) ||
      (NULL == GST_peer_list[peer_id]))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_break_op, GNUNET_MESSAGE_TYPE_HELLO, GNUNET_OK, GNUNET_SYSERR, GST_peer_list, GST_peer_list_size, msg, peer_id, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

handle_remote_overlay_connect()

void handle_remote_overlay_connect	(	void *	cls,
		const struct GNUNET_TESTBED_RemoteOverlayConnectMessage *	msg
	)

Handler for GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1909 of file gnunet-service-testbed_oc.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct RemoteOverlayConnectCtx *rocc;
  struct Peer *peer;
  struct GNUNET_PeerIdentity pid;
  static char pid_str[16];
  uint32_t peer_id;
  uint16_t hsize;
 
  hsize = ntohs (msg->hello->size);
  peer_id = ntohl (msg->peer);
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    struct GNUNET_MessageHeader *msg2;
 
    msg2 = GNUNET_copy_message (&msg->header);
    GNUNET_TESTBED_queue_message_ (peer->details.remote.slave->controller,
                                   msg2);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  rocc = GNUNET_new (struct RemoteOverlayConnectCtx);
  rocc->op_id = GNUNET_ntohll (msg->operation_id);
  GNUNET_CONTAINER_DLL_insert_tail (roccq_head,
                                    roccq_tail,
                                    rocc);
  rocc->a_id = msg->peer_identity;
  GNUNET_TESTING_peer_get_identity (peer->details.local.peer,
                                    &pid);
  (void) GNUNET_strlcpy (pid_str,
                         GNUNET_i2s (&pid),
                         sizeof(pid_str));
  LOG_DEBUG (
    "0x%llx: Remote overlay connect %s to peer %s with hello size: %u\n",
    (unsigned long long) rocc->op_id,
    pid_str,
    GNUNET_i2s (&rocc->a_id),
    hsize);
  rocc->peer = peer;
  rocc->peer->reference_cnt++;
  rocc->hello = GNUNET_malloc (hsize);
  GNUNET_memcpy (rocc->hello,
                 msg->hello,
                 hsize);
  rocc->tcc.cgh_p2_th =
    GST_connection_pool_get_handle (peer_id,
                                    rocc->peer->details.local.cfg,
                                    GST_CONNECTIONPOOL_SERVICE_TRANSPORT,
                                    &rocc_cache_get_handle_transport_cb,
                                    rocc,
                                    &rocc->a_id,
                                    &cache_transport_peer_connect_notify,
                                    rocc);
  rocc->timeout_rocc_task_id =
    GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                  &timeout_rocc_task,
                                  rocc);
  GNUNET_SERVICE_client_continue (client);
}

References RemoteOverlayConnectCtx::a_id, cache_transport_peer_connect_notify(), ConnectivitySuggestContext::cgh_p2_th, GNUNET_TESTBED_Peer::controller, Peer::details, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_copy_message(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_strlcpy(), GNUNET_TESTBED_queue_message_(), GNUNET_TESTING_peer_get_identity(), GNUNET_YES, GST_connection_pool_get_handle(), GST_CONNECTIONPOOL_SERVICE_TRANSPORT, GST_peer_list, GST_timeout, RemoteOverlayConnectCtx::hello, Peer::local, LOG_DEBUG, msg, RemoteOverlayConnectCtx::op_id, RemoteOverlayConnectCtx::peer, peer, peer_id, pid, Peer::reference_cnt, rocc_cache_get_handle_transport_cb(), roccq_head, roccq_tail, GNUNET_MessageHeader::size, RemoteOverlayConnectCtx::tcc, timeout_rocc_task(), and RemoteOverlayConnectCtx::timeout_rocc_task_id.

Here is the call graph for this function:

check_peer_create()

int check_peer_create	(	void *	cls,
		const struct GNUNET_TESTBED_PeerCreateMessage *	msg
	)

Check #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 425 of file gnunet-service-testbed_peers.c.

{
  return GNUNET_OK; /* checked later */
}

References GNUNET_OK.

handle_peer_create()

void handle_peer_create	(	void *	cls,
		const struct GNUNET_TESTBED_PeerCreateMessage *	msg
	)

Handler for #GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 433 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *reply;
  struct GNUNET_CONFIGURATION_Handle *cfg;
  struct ForwardedOperationContext *fo_ctxt;
  struct Route *route;
  struct Peer *peer;
  char *emsg;
  uint32_t host_id;
  uint32_t peer_id;
 
  host_id = ntohl (msg->host_id);
  peer_id = ntohl (msg->peer_id);
  if (VALID_PEER_ID (peer_id))
  {
    (void) GNUNET_asprintf (&emsg,
                            "Peer with ID %u already exists",
                            peer_id);
    GST_send_operation_fail_msg (client,
                                 GNUNET_ntohll (msg->operation_id),
                                 emsg);
    GNUNET_free (emsg);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (UINT32_MAX == peer_id)
  {
    GST_send_operation_fail_msg (client,
                                 GNUNET_ntohll (msg->operation_id),
                                 "Cannot create peer with given ID");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (host_id == GST_context->host_id)
  {
    /* We are responsible for this peer */
    cfg = GNUNET_TESTBED_extract_config_ (&msg->header);
    if (NULL == cfg)
    {
      GNUNET_break (0);
      GNUNET_SERVICE_client_drop (client);
      return;
    }
    GNUNET_CONFIGURATION_set_value_number (cfg,
                                           "TESTBED",
                                           "PEERID",
                                           (unsigned long long) peer_id);
 
    GNUNET_CONFIGURATION_set_value_number (cfg,
                                           "PATHS",
                                           "PEERID",
                                           (unsigned long long) peer_id);
    peer = GNUNET_new (struct Peer);
    peer->is_remote = GNUNET_NO;
    peer->details.local.cfg = cfg;
    peer->id = peer_id;
    LOG_DEBUG ("Creating peer with id: %u\n",
               (unsigned int) peer->id);
    peer->details.local.peer =
      GNUNET_TESTING_peer_configure (GST_context->system,
                                     peer->details.local.cfg, peer->id,
                                     NULL /* Peer id */,
                                     &emsg);
    if (NULL == peer->details.local.peer)
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Configuring peer failed: %s\n",
           emsg);
      GNUNET_free (emsg);
      GNUNET_free (peer);
      GNUNET_break (0);
      GNUNET_SERVICE_client_drop (client);
      return;
    }
    peer->details.local.is_running = GNUNET_NO;
    peer_list_add (peer);
    env = GNUNET_MQ_msg (reply,
                         GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS);
    reply->peer_id = msg->peer_id;
    reply->operation_id = msg->operation_id;
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                    env);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
 
  /* Forward peer create request */
  route = GST_find_dest_route (host_id);
  if (NULL == route)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_continue (client);  // ?
    return;
  }
  peer = GNUNET_new (struct Peer);
  peer->is_remote = GNUNET_YES;
  peer->id = peer_id;
  peer->details.remote.slave = GST_slave_list[route->dest];
  peer->details.remote.remote_host_id = host_id;
  fo_ctxt = GNUNET_new (struct ForwardedOperationContext);
  fo_ctxt->client = client;
  fo_ctxt->operation_id = GNUNET_ntohll (msg->operation_id);
  fo_ctxt->cls = peer;
  fo_ctxt->type = OP_PEER_CREATE;
  fo_ctxt->opc =
    GNUNET_TESTBED_forward_operation_msg_ (GST_slave_list
                                           [route->dest]->controller,
                                           fo_ctxt->operation_id,
                                           &msg->header,
                                           &peer_create_success_cb,
                                           fo_ctxt);
  fo_ctxt->timeout_task =
    GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                  &peer_create_forward_timeout,
                                  fo_ctxt);
  GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                    fopcq_tail,
                                    fo_ctxt);
  GNUNET_SERVICE_client_continue (client);
}

References cfg, ForwardedOperationContext::client, ForwardedOperationContext::cls, Slave::controller, Route::dest, env, fopcq_head, fopcq_tail, GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_extract_config_(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_TESTING_peer_configure(), GNUNET_YES, GST_context, GST_find_dest_route(), GST_send_operation_fail_msg(), GST_slave_list, GST_timeout, Context::host_id, LOG, LOG_DEBUG, msg, OP_PEER_CREATE, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerCreateSuccessEventMessage::operation_id, peer, peer_create_forward_timeout(), peer_create_success_cb(), peer_id, GNUNET_TESTBED_PeerCreateSuccessEventMessage::peer_id, peer_list_add(), Context::system, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Here is the call graph for this function:

handle_peer_destroy()

void handle_peer_destroy	(	void *	cls,
		const struct GNUNET_TESTBED_PeerDestroyMessage *	msg
	)

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 565 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct ForwardedOperationContext *fopc;
  struct Peer *peer;
  uint32_t peer_id;
 
  peer_id = ntohl (msg->peer_id);
  LOG_DEBUG ("Received peer destroy on peer: %u and operation id: %llu\n",
             (unsigned int) peer_id,
             (unsigned long long) GNUNET_ntohll (msg->operation_id));
  if (! VALID_PEER_ID (peer_id))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Asked to destroy a non existent peer with id: %u\n", peer_id);
    GST_send_operation_fail_msg (client,
                                 GNUNET_ntohll (msg->operation_id),
                                 "Peer doesn't exist");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    /* Forward the destroy message to sub controller */
    fopc = GNUNET_new (struct ForwardedOperationContext);
    fopc->client = client;
    fopc->cls = peer;
    fopc->type = OP_PEER_DESTROY;
    fopc->operation_id = GNUNET_ntohll (msg->operation_id);
    fopc->opc =
      GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
                                             slave->controller,
                                             fopc->operation_id,
                                             &msg->header,
                                             &peer_destroy_success_cb,
                                             fopc);
    fopc->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &GST_forwarded_operation_timeout,
                                    fopc);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fopc);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  peer->destroy_flag = GNUNET_YES;
  if (0 == peer->reference_cnt)
    GST_destroy_peer (peer);
  else
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Delaying peer destroy as peer is currently in use\n");
  GST_send_operation_success_msg (client,
                                  GNUNET_ntohll (msg->operation_id));
  GNUNET_SERVICE_client_continue (client);
}

References ForwardedOperationContext::client, ForwardedOperationContext::cls, Slave::controller, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_YES, GST_destroy_peer(), GST_forwarded_operation_timeout(), GST_peer_list, GST_send_operation_fail_msg(), GST_send_operation_success_msg(), GST_timeout, LOG, LOG_DEBUG, msg, OP_PEER_DESTROY, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, peer, peer_destroy_success_cb(), peer_id, Peer::slave, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Here is the call graph for this function:

handle_peer_start()

void handle_peer_start	(	void *	cls,
		const struct GNUNET_TESTBED_PeerStartMessage *	msg
	)

Message handler for GNUNET_MESSAGE_TYPE_TESTBED_START_PEER messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 643 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_PeerEventMessage *reply;
  struct ForwardedOperationContext *fopc;
  struct Peer *peer;
  uint32_t peer_id;
 
  peer_id = ntohl (msg->peer_id);
  if (! VALID_PEER_ID (peer_id))
  {
    GNUNET_break (0);
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Asked to start a non existent peer with id: %u\n",
         peer_id);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    fopc = GNUNET_new (struct ForwardedOperationContext);
    fopc->client = client;
    fopc->operation_id = GNUNET_ntohll (msg->operation_id);
    fopc->type = OP_PEER_START;
    fopc->opc =
      GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
                                             slave->controller,
                                             fopc->operation_id, &msg->header,
                                             &
                                             GST_forwarded_operation_reply_relay,
                                             fopc);
    fopc->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &GST_forwarded_operation_timeout,
                                    fopc);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fopc);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (GNUNET_OK != start_peer (peer))
  {
    GST_send_operation_fail_msg (client, GNUNET_ntohll (msg->operation_id),
                                 "Failed to start");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  env = GNUNET_MQ_msg (reply,
                       GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT);
  reply->event_type = htonl (GNUNET_TESTBED_ET_PEER_START);
  reply->host_id = htonl (GST_context->host_id);
  reply->peer_id = msg->peer_id;
  reply->operation_id = msg->operation_id;
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
  GNUNET_SERVICE_client_continue (client);
}

References ForwardedOperationContext::client, Slave::controller, env, GNUNET_TESTBED_PeerEventMessage::event_type, fopcq_head, fopcq_tail, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_ntohll(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_forward_operation_msg_(), GNUNET_YES, GST_context, GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_peer_list, GST_send_operation_fail_msg(), GST_timeout, Context::host_id, GNUNET_TESTBED_PeerEventMessage::host_id, LOG, msg, OP_PEER_START, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerEventMessage::operation_id, peer, peer_id, GNUNET_TESTBED_PeerEventMessage::peer_id, Peer::slave, start_peer(), ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Here is the call graph for this function:

handle_peer_stop()

void handle_peer_stop	(	void *	cls,
		const struct GNUNET_TESTBED_PeerStopMessage *	msg
	)

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages.

Parameters

cls	identification of the client
msg	the actual message

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 713 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_PeerEventMessage *reply;
  struct ForwardedOperationContext *fopc;
  struct Peer *peer;
  uint32_t peer_id;
 
  peer_id = ntohl (msg->peer_id);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received PEER_STOP for peer %u\n",
       (unsigned int) peer_id);
  if (! VALID_PEER_ID (peer_id))
  {
    GST_send_operation_fail_msg (client,
                                 GNUNET_ntohll (msg->operation_id),
                                 "Peer not found");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Forwarding PEER_STOP for peer %u\n",
         (unsigned int) peer_id);
    fopc = GNUNET_new (struct ForwardedOperationContext);
    fopc->client = client;
    fopc->operation_id = GNUNET_ntohll (msg->operation_id);
    fopc->type = OP_PEER_STOP;
    fopc->opc =
      GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
                                             slave->controller,
                                             fopc->operation_id,
                                             &msg->header,
                                             &
                                             GST_forwarded_operation_reply_relay,
                                             fopc);
    fopc->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &GST_forwarded_operation_timeout,
                                    fopc);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fopc);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (GNUNET_OK != stop_peer (peer))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Stopping peer %u failed\n",
         (unsigned int) peer_id);
    GST_send_operation_fail_msg (client,
                                 GNUNET_ntohll (msg->operation_id),
                                 "Peer not running");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Peer %u successfully stopped\n",
       (unsigned int) peer_id);
  env = GNUNET_MQ_msg (reply,
                       GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT);
  reply->event_type = htonl (GNUNET_TESTBED_ET_PEER_STOP);
  reply->host_id = htonl (GST_context->host_id);
  reply->peer_id = msg->peer_id;
  reply->operation_id = msg->operation_id;
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
  GNUNET_SERVICE_client_continue (client);
  GNUNET_TESTING_peer_wait (peer->details.local.peer);
}

References ForwardedOperationContext::client, Slave::controller, env, GNUNET_TESTBED_PeerEventMessage::event_type, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_ntohll(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_PEER_STOP, GNUNET_TESTBED_forward_operation_msg_(), GNUNET_TESTING_peer_wait(), GNUNET_YES, GST_context, GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_peer_list, GST_send_operation_fail_msg(), GST_timeout, Context::host_id, GNUNET_TESTBED_PeerEventMessage::host_id, LOG, msg, OP_PEER_STOP, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerEventMessage::operation_id, peer, peer_id, GNUNET_TESTBED_PeerEventMessage::peer_id, Peer::slave, stop_peer(), ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Here is the call graph for this function:

handle_peer_get_config()

void handle_peer_get_config	(	void *	cls,
		const struct GNUNET_TESTBED_PeerGetConfigurationMessage *	msg
	)

Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG messages.

Parameters

cls	identification of the client
msg	the actual message

Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 797 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_PeerConfigurationInformationMessage *reply;
  struct ForwardedOperationContext *fopc;
  struct Peer *peer;
  char *config;
  char *xconfig;
  size_t c_size;
  size_t xc_size;
  uint32_t peer_id;
 
  peer_id = ntohl (msg->peer_id);
  LOG_DEBUG ("Received GET_CONFIG for peer %u\n",
             (unsigned int) peer_id);
  if (! VALID_PEER_ID (peer_id))
  {
    GST_send_operation_fail_msg (client,
                                 GNUNET_ntohll (msg->operation_id),
                                 "Peer not found");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    LOG_DEBUG ("Forwarding PEER_GET_CONFIG for peer: %u\n",
               (unsigned int) peer_id);
    fopc = GNUNET_new (struct ForwardedOperationContext);
    fopc->client = client;
    fopc->operation_id = GNUNET_ntohll (msg->operation_id);
    fopc->type = OP_PEER_INFO;
    fopc->opc =
      GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
                                             slave->controller,
                                             fopc->operation_id,
                                             &msg->header,
                                             &
                                             GST_forwarded_operation_reply_relay,
                                             fopc);
    fopc->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &GST_forwarded_operation_timeout,
                                    fopc);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fopc);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  LOG_DEBUG ("Received PEER_GET_CONFIG for peer: %u\n",
             peer_id);
  config =
    GNUNET_CONFIGURATION_serialize (GST_peer_list[peer_id]->details.local.cfg,
                                    &c_size);
  xc_size = GNUNET_TESTBED_compress_config_ (config,
                                             c_size,
                                             &xconfig);
  GNUNET_free (config);
  env = GNUNET_MQ_msg_extra (reply,
                             xc_size,
                             GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION);
  reply->peer_id = msg->peer_id;
  reply->operation_id = msg->operation_id;
  GNUNET_TESTING_peer_get_identity (GST_peer_list[peer_id]->details.local.peer,
                                    &reply->peer_identity);
  reply->config_size = htons ((uint16_t) c_size);
  GNUNET_memcpy (&reply[1],
                 xconfig,
                 xc_size);
  GNUNET_free (xconfig);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
  GNUNET_SERVICE_client_continue (client);
}

References ForwardedOperationContext::client, config, GNUNET_TESTBED_PeerConfigurationInformationMessage::config_size, Slave::controller, Peer::details, env, fopcq_head, fopcq_tail, GNUNET_CONFIGURATION_serialize(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_compress_config_(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_TESTING_peer_get_identity(), GNUNET_YES, GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_peer_list, GST_send_operation_fail_msg(), GST_timeout, LOG_DEBUG, msg, OP_PEER_INFO, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerConfigurationInformationMessage::operation_id, peer, peer_id, GNUNET_TESTBED_PeerConfigurationInformationMessage::peer_id, GNUNET_TESTBED_PeerConfigurationInformationMessage::peer_identity, Peer::slave, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Here is the call graph for this function:

handle_shutdown_peers()

void handle_shutdown_peers	(	void *	cls,
		const struct GNUNET_TESTBED_ShutdownPeersMessage *	msg
	)

Handler for GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1498 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct HandlerContext_ShutdownPeers *hc;
  struct Slave *slave;
  struct ForwardedOperationContext *fo_ctxt;
  uint64_t op_id;
  unsigned int cnt;
 
  LOG_DEBUG ("Received SHUTDOWN_PEERS\n");
  /* Stop and destroy all peers */
  GST_free_mctxq ();
  GST_free_occq ();
  GST_free_roccq ();
  GST_clear_fopcq ();
  /* Forward to all slaves which we have started */
  op_id = GNUNET_ntohll (msg->operation_id);
  hc = GNUNET_new (struct HandlerContext_ShutdownPeers);
  /* FIXME: have a better implementation where we track which slaves are
     started by this controller */
  for (cnt = 0; cnt < GST_slave_list_size; cnt++)
  {
    slave = GST_slave_list[cnt];
    if (NULL == slave)
      continue;
    if (NULL == slave->controller_proc)   /* We didn't start the slave */
      continue;
    LOG_DEBUG ("Forwarding SHUTDOWN_PEERS\n");
    hc->nslaves++;
    fo_ctxt = GNUNET_new (struct ForwardedOperationContext);
    fo_ctxt->client = client;
    fo_ctxt->operation_id = op_id;
    fo_ctxt->cls = hc;
    fo_ctxt->type = OP_SHUTDOWN_PEERS;
    fo_ctxt->opc =
      GNUNET_TESTBED_forward_operation_msg_ (slave->controller,
                                             fo_ctxt->operation_id,
                                             &msg->header,
                                             shutdown_peers_reply_cb,
                                             fo_ctxt);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fo_ctxt);
  }
  LOG_DEBUG ("Shutting down peers\n");
  GST_destroy_peers ();
  if (0 == hc->nslaves)
  {
    GST_send_operation_success_msg (client,
                                    op_id);
    GNUNET_free (hc);
  }
  GNUNET_SERVICE_client_continue (client);
}

References ForwardedOperationContext::client, ForwardedOperationContext::cls, Slave::controller, Slave::controller_proc, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_free, GNUNET_new, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_TESTBED_forward_operation_msg_(), GST_clear_fopcq(), GST_destroy_peers(), GST_free_mctxq(), GST_free_occq(), GST_free_roccq(), GST_send_operation_success_msg(), GST_slave_list, GST_slave_list_size, LOG_DEBUG, msg, HandlerContext_ShutdownPeers::nslaves, OP_SHUTDOWN_PEERS, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, shutdown_peers_reply_cb(), and ForwardedOperationContext::type.

Here is the call graph for this function:

check_manage_peer_service()

int check_manage_peer_service	(	void *	cls,
		const struct GNUNET_TESTBED_ManagePeerServiceMessage *	msg
	)

Check GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE message.

Parameters

cls	identification of client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 1269 of file gnunet-service-testbed_peers.c.

{
  uint16_t msize;
  const char*service;
 
  msize = ntohs (msg->header.size);
  service = (const char *) &msg[1];
  if ('\0' != service[msize - sizeof
                      (struct GNUNET_TESTBED_ManagePeerServiceMessage) - 1])
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (1 < msg->start)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, msg, service, and GNUNET_MessageHeader::size.

handle_manage_peer_service()

void handle_manage_peer_service	(	void *	cls,
		const struct GNUNET_TESTBED_ManagePeerServiceMessage *	msg
	)

Handler for GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE messages.

Parameters

cls	identification of client
msg	the actual message

Definition at line 1294 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  const char*service;
  struct Peer *peer;
  char *emsg;
  struct GNUNET_ARM_Handle *ah;
  struct ManageServiceContext *mctx;
  struct ForwardedOperationContext *fopc;
  uint64_t op_id;
  uint32_t peer_id;
 
  service = (const char *) &msg[1];
  peer_id = ntohl (msg->peer_id);
  op_id = GNUNET_ntohll (msg->operation_id);
  LOG_DEBUG ("Received request to manage service %s on peer %u\n",
             service, (unsigned int) peer_id);
  if ((GST_peer_list_size <= peer_id)
      || (NULL == (peer = GST_peer_list[peer_id])))
  {
    GNUNET_asprintf (&emsg, "Asked to manage service of a non existent peer "
                     "with id: %u", peer_id);
    goto err_ret;
  }
  if (0 == strcasecmp ("arm", service))
  {
    emsg = GNUNET_strdup ("Cannot start/stop peer's ARM service.  "
                          "Use peer start/stop for that");
    goto err_ret;
  }
  if (GNUNET_YES == peer->is_remote)
  {
    /* Forward the destroy message to sub controller */
    fopc = GNUNET_new (struct ForwardedOperationContext);
    fopc->client = client;
    fopc->cls = peer;
    fopc->type = OP_MANAGE_SERVICE;
    fopc->operation_id = op_id;
    fopc->opc =
      GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
                                             slave->controller,
                                             fopc->operation_id,
                                             &msg->header,
                                             &
                                             GST_forwarded_operation_reply_relay,
                                             fopc);
    fopc->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &GST_forwarded_operation_timeout,
                                    fopc);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fopc);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (GNUNET_NO == peer->details.local.is_running)
  {
    emsg = GNUNET_strdup ("Peer not running\n");
    goto err_ret;
  }
  if ((0 != peer->reference_cnt)
      && ((0 == strcasecmp ("core", service))
          || (0 == strcasecmp ("transport", service))))
  {
    GNUNET_asprintf (&emsg, "Cannot stop %s service of peer with id: %u "
                     "since it is required by existing operations",
                     service, peer_id);
    goto err_ret;
  }
  ah = GNUNET_ARM_connect (peer->details.local.cfg, NULL, NULL);
  if (NULL == ah)
  {
    GNUNET_asprintf (&emsg,
                     "Cannot connect to ARM service of peer with id: %u",
                     peer_id);
    goto err_ret;
  }
  mctx = GNUNET_new (struct ManageServiceContext);
  mctx->peer = peer;
  peer->reference_cnt++;
  mctx->op_id = op_id;
  mctx->ah = ah;
  mctx->client = client;
  mctx->start = msg->start;
  mctx->service = GNUNET_strdup (service);
  GNUNET_CONTAINER_DLL_insert_tail (mctx_head,
                                    mctx_tail,
                                    mctx);
  if (1 == mctx->start)
    GNUNET_ARM_request_service_start (mctx->ah,
                                      service,
                                      GNUNET_OS_INHERIT_STD_ERR,
                                      &service_manage_result_cb,
                                      mctx);
  else
    GNUNET_ARM_request_service_stop (mctx->ah, service,
                                     &service_manage_result_cb,
                                     mctx);
  GNUNET_SERVICE_client_continue (client);
  return;
 
err_ret:
  LOG (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
  GST_send_operation_fail_msg (client, op_id, emsg);
  GNUNET_free (emsg);
  GNUNET_SERVICE_client_continue (client);
}

References ah, ManageServiceContext::ah, ForwardedOperationContext::client, ManageServiceContext::client, ForwardedOperationContext::cls, GNUNET_TESTBED_Peer::controller, fopcq_head, fopcq_tail, GNUNET_ARM_connect(), GNUNET_ARM_request_service_start(), GNUNET_ARM_request_service_stop(), GNUNET_asprintf(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_OS_INHERIT_STD_ERR, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_TESTBED_forward_operation_msg_(), GNUNET_YES, GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_peer_list, GST_peer_list_size, GST_send_operation_fail_msg(), GST_timeout, LOG, LOG_DEBUG, mctx_head, mctx_tail, msg, ManageServiceContext::op_id, OP_MANAGE_SERVICE, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, ManageServiceContext::peer, peer, peer_id, service, ManageServiceContext::service, service_manage_result_cb(), ManageServiceContext::start, ForwardedOperationContext::timeout_task, and ForwardedOperationContext::type.

Here is the call graph for this function:

check_peer_reconfigure()

int check_peer_reconfigure	(	void *	cls,
		const struct GNUNET_TESTBED_PeerReconfigureMessage *	msg
	)

Check #GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER type messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 969 of file gnunet-service-testbed_peers.c.

{
  return GNUNET_OK; /* checked later */
}

References GNUNET_OK.

handle_peer_reconfigure()

void handle_peer_reconfigure	(	void *	cls,
		const struct GNUNET_TESTBED_PeerReconfigureMessage *	msg
	)

Handler for #GNUNET_MESSAGE_TYPDE_TESTBED_RECONFIGURE_PEER type messages.

Should stop the peer asynchronously, destroy it and create it again with the new configuration.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 985 of file gnunet-service-testbed_peers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct Peer *peer;
  struct GNUNET_CONFIGURATION_Handle *cfg;
  struct ForwardedOperationContext *fopc;
  struct PeerReconfigureContext *prc;
  char *emsg;
  uint64_t op_id;
  uint32_t peer_id;
 
  peer_id = ntohl (msg->peer_id);
  op_id = GNUNET_ntohll (msg->operation_id);
  if (! VALID_PEER_ID (peer_id))
  {
    GNUNET_break (0);
    GST_send_operation_fail_msg (client,
                                 op_id,
                                 "Peer not found");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  peer = GST_peer_list[peer_id];
  if (GNUNET_YES == peer->is_remote)
  {
    LOG_DEBUG ("Forwarding PEER_RECONFIGURE for peer: %u\n", peer_id);
    fopc = GNUNET_new (struct ForwardedOperationContext);
    fopc->client = client;
    fopc->operation_id = op_id;
    fopc->type = OP_PEER_RECONFIGURE;
    fopc->opc =
      GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.
                                             slave->controller,
                                             fopc->operation_id,
                                             &msg->header,
                                             &
                                             GST_forwarded_operation_reply_relay,
                                             fopc);
    fopc->timeout_task =
      GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                    &GST_forwarded_operation_timeout,
                                    fopc);
    GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                      fopcq_tail,
                                      fopc);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  LOG_DEBUG ("Received PEER_RECONFIGURE for peer %u\n",
             (unsigned int) peer_id);
  if (0 < peer->reference_cnt)
  {
    GNUNET_break (0);
    GST_send_operation_fail_msg (client,
                                 op_id,
                                 "Peer in use");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (GNUNET_YES == peer->destroy_flag)
  {
    GNUNET_break (0);
    GST_send_operation_fail_msg (client,
                                 op_id,
                                 "Peer is being destroyed");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  cfg = GNUNET_TESTBED_extract_config_ (&msg->header);
  if (NULL == cfg)
  {
    GNUNET_break (0);
    GST_send_operation_fail_msg (client,
                                 op_id,
                                 "Compression error");
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  if (GNUNET_NO == peer->details.local.is_running)
  {
    emsg = update_peer_config (peer,
                               cfg);
    if (NULL != emsg)
      GST_send_operation_fail_msg (client,
                                   op_id,
                                   emsg);
    GST_send_operation_success_msg (client,
                                    op_id);
    GNUNET_SERVICE_client_continue (client);
    GNUNET_free (emsg);
    return;
  }
  prc = GNUNET_new (struct PeerReconfigureContext);
  if (GNUNET_OK !=
      GNUNET_TESTING_peer_stop_async (peer->details.local.peer,
                                      &prc_stop_cb,
                                      prc))
  {
    GNUNET_assert (0 < GNUNET_asprintf (&emsg,
                                        "Error trying to stop peer %u asynchronously\n",
                                        peer_id));
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "%s\n",
         emsg);
    GST_send_operation_fail_msg (client,
                                 op_id,
                                 emsg);
    GNUNET_SERVICE_client_continue (client);
    GNUNET_free (prc);
    GNUNET_free (emsg);
    return;
  }
  prc->cfg = cfg;
  prc->peer_id = peer_id;
  prc->op_id = op_id;
  prc->client = client;
  GNUNET_CONTAINER_DLL_insert_tail (prc_head,
                                    prc_tail,
                                    prc);
  GNUNET_SERVICE_client_continue (client);
}

References cfg, PeerReconfigureContext::cfg, ForwardedOperationContext::client, PeerReconfigureContext::client, GNUNET_TESTBED_Peer::controller, fopcq_head, fopcq_tail, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_TESTBED_extract_config_(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_TESTING_peer_stop_async(), GNUNET_YES, GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_peer_list, GST_send_operation_fail_msg(), GST_send_operation_success_msg(), GST_timeout, LOG, LOG_DEBUG, msg, PeerReconfigureContext::op_id, OP_PEER_RECONFIGURE, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, peer, peer_id, PeerReconfigureContext::peer_id, prc_head, prc_stop_cb(), prc_tail, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, update_peer_config(), and VALID_PEER_ID.

Here is the call graph for this function:

GST_free_mctxq()

void GST_free_mctxq

(

void

)

Frees the ManageServiceContext queue.

Definition at line 1114 of file gnunet-service-testbed_peers.c.

{
  while (NULL != mctx_head)
    cleanup_mctx (mctx_head);
}

References cleanup_mctx(), and mctx_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_free_lcf()

void GST_free_lcf

(

void

)

Cleans up the queue used for forwarding link controllers requests.

Definition at line 1444 of file gnunet-service-testbed_links.c.

{
  struct LCFContext *lcf;
 
  if (NULL != lcf_head)
  {
    if (NULL != lcf_proc_task_id)
    {
      GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
      lcf_proc_task_id = NULL;
    }
  }
  GNUNET_assert (NULL == lcf_proc_task_id);
  for (lcf = lcf_head; NULL != lcf; lcf = lcf_head)
  {
    if (NULL != lcf->op)
      GNUNET_TESTBED_operation_done (lcf->op);
    if (NULL != lcf->timeout_task)
      GNUNET_SCHEDULER_cancel (lcf->timeout_task);
    GNUNET_CONTAINER_DLL_remove (lcf_head,
                                 lcf_tail,
                                 lcf);
    GNUNET_free (lcf);
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_operation_done(), lcf_head, lcf_proc_task_id, lcf_tail, LCFContext::op, and LCFContext::timeout_task.

Referenced by shutdown_task(), and slave_status_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_route_list_clear()

void GST_route_list_clear

(

void

)

Cleans up the route list.

Definition at line 398 of file gnunet-service-testbed_links.c.

{
  unsigned int id;
 
  for (id = 0; id < route_list_size; id++)
    if (NULL != route_list[id])
      GNUNET_free (route_list[id]);
  GNUNET_free (route_list);
  route_list = NULL;
}

References GNUNET_free, id, route_list, and route_list_size.

Referenced by shutdown_task().

Here is the caller graph for this function:

GST_process_next_focc()

void GST_process_next_focc

(

struct RegisteredHostContext *

rhc

)

Processes a forwarded overlay connect context in the queue of the given RegisteredHostContext.

Parameters

rhc	the RegisteredHostContext

Definition at line 425 of file gnunet-service-testbed_oc.c.

{
  struct ForwardedOperationContext *fopc;
  struct ForwardedOverlayConnectContext *focc;
  struct Peer *peer;
  struct Slave *slave;
 
  focc = rhc->focc_dll_head;
  GNUNET_assert (NULL != focc);
  GNUNET_assert (RHC_DONE == rhc->state);
  GNUNET_assert (VALID_PEER_ID (focc->peer1));
  peer = GST_peer_list[focc->peer1];
  GNUNET_assert (GNUNET_YES == peer->is_remote);
  GNUNET_assert (NULL != (slave = peer->details.remote.slave));
  fopc = GNUNET_new (struct ForwardedOperationContext);
  fopc->client = focc->client;
  fopc->operation_id = focc->operation_id;
  fopc->cls = rhc;
  fopc->type = OP_OVERLAY_CONNECT;
  fopc->opc =
    GNUNET_TESTBED_forward_operation_msg_ (slave->controller,
                                           focc->operation_id,
                                           focc->orig_msg,
                                           &forwarded_overlay_connect_listener,
                                           fopc);
  GNUNET_free (focc->orig_msg);
  focc->orig_msg = NULL;
  fopc->timeout_task = GNUNET_SCHEDULER_add_delayed (GST_timeout,
                                                     &
                                                     forwarded_overlay_connect_timeout,
                                                     fopc);
  GNUNET_CONTAINER_DLL_insert_tail (fopcq_head,
                                    fopcq_tail,
                                    fopc);
}

References ForwardedOperationContext::client, ForwardedOverlayConnectContext::client, ForwardedOperationContext::cls, Slave::controller, RegisteredHostContext::focc_dll_head, fopcq_head, fopcq_tail, forwarded_overlay_connect_listener(), forwarded_overlay_connect_timeout(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_free, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTBED_forward_operation_msg_(), GNUNET_YES, GST_peer_list, GST_timeout, OP_OVERLAY_CONNECT, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, ForwardedOverlayConnectContext::operation_id, ForwardedOverlayConnectContext::orig_msg, peer, ForwardedOverlayConnectContext::peer1, RegisteredHostContext::state, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

Referenced by forwarded_overlay_connect_listener(), forwarded_overlay_connect_timeout(), and host_registration_comp().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_cleanup_focc()

void GST_cleanup_focc

(

struct ForwardedOverlayConnectContext *

focc

)

Cleans up ForwardedOverlayConnectContext.

Parameters

focc	the ForwardedOverlayConnectContext to cleanup

Definition at line 357 of file gnunet-service-testbed_oc.c.

{
  struct RegisteredHostContext *rhc = focc->rhc;
 
  GNUNET_CONTAINER_DLL_remove (rhc->focc_dll_head,
                               rhc->focc_dll_tail,
                               focc);
  GNUNET_free (focc->orig_msg);
  GNUNET_free (focc);
}

References RegisteredHostContext::focc_dll_head, RegisteredHostContext::focc_dll_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, ForwardedOverlayConnectContext::orig_msg, and ForwardedOverlayConnectContext::rhc.

Referenced by drop_client_entries(), forwarded_overlay_connect_listener(), forwarded_overlay_connect_timeout(), and reghost_free_iterator().

Here is the caller graph for this function:

GST_free_occq()

void GST_free_occq

(

void

)

Clears all pending overlay connect contexts in queue.

Definition at line 1978 of file gnunet-service-testbed_oc.c.

{
  struct OverlayConnectContext *occ;
 
  while (NULL != (occ = occq_head))
    cleanup_occ (occ);
}

References cleanup_occ(), and occq_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_free_roccq()

void GST_free_roccq

(

void

)

Clears all pending remote overlay connect contexts in queue.

Definition at line 1991 of file gnunet-service-testbed_oc.c.

{
  struct RemoteOverlayConnectCtx *rocc;
 
  while (NULL != (rocc = roccq_head))
    cleanup_rocc (rocc);
}

References cleanup_rocc(), and roccq_head.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_free_prcq()

void GST_free_prcq

(

void

)

Cleans up the Peer reconfigure context list.

Definition at line 881 of file gnunet-service-testbed_peers.c.

{
  while (NULL != prc_head)
    cleanup_prc (prc_head);
}

References cleanup_prc(), and prc_head.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_cache_init()

void GST_cache_init

(

unsigned int

size

)

Initializes the cache.

Parameters

size	the size of the cache

Definition at line 212 of file gnunet-service-testbed_cache.c.

{
  if (0 == size)
    return;
  cache_size = size;
  cache = GNUNET_CONTAINER_multihashmap32_create (cache_size);
}

References cache, cache_size, GNUNET_CONTAINER_multihashmap32_create(), and size.

Referenced by testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_cache_clear()

void GST_cache_clear

(

void

)

Clear cache.

Definition at line 190 of file gnunet-service-testbed_cache.c.

{
  if (NULL != cache)
  {
    GNUNET_CONTAINER_multihashmap32_iterate (cache, &cache_clear_iterator,
                                             NULL);
    GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (cache));
    GNUNET_CONTAINER_multihashmap32_destroy (cache);
    cache = NULL;
  }
  cache_size = 0;
  cache_head = NULL;
  cache_tail = NULL;
}

References cache, cache_clear_iterator(), cache_head, cache_size, cache_tail, GNUNET_assert, GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), and GNUNET_CONTAINER_multihashmap32_size().

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_cache_lookup_hello()

const struct GNUNET_MessageHeader* GST_cache_lookup_hello

(

const unsigned int

peer_id

)

Looks up in the hello cache and returns the HELLO of the given peer.

Parameters

peer_id

the index of the peer whose HELLO has to be looked up

Returns

the HELLO message; NULL if not found

Definition at line 228 of file gnunet-service-testbed_cache.c.

{
  struct CacheEntry *entry;
 
  LOG_DEBUG ("Looking up HELLO for peer %u\n", peer_id);
  if (NULL == cache)
  {
    LOG_DEBUG ("Caching disabled\n");
    return NULL;
  }
  entry = cache_lookup (peer_id);
  if (NULL == entry)
    return NULL;
  if (NULL != entry->hello)
    LOG_DEBUG ("HELLO found for peer %u\n", peer_id);
  return entry->hello;
}

References cache, cache_lookup(), CacheEntry::hello, LOG_DEBUG, and peer_id.

Referenced by occ_cache_get_handle_core_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_cache_add_hello()

void GST_cache_add_hello	(	const unsigned int	peer_id,
		const struct GNUNET_MessageHeader *	hello
	)

Caches the HELLO of the given peer.

Updates the HELLO if it was already cached before

Parameters

peer_id	the peer identity of the peer whose HELLO has to be cached
hello	the HELLO message

Definition at line 255 of file gnunet-service-testbed_cache.c.

{
  struct CacheEntry *entry;
 
  if (NULL == cache)
    return;
  entry = cache_lookup (peer_id);
  if (NULL == entry)
    entry = add_entry (peer_id);
  GNUNET_free (entry->hello);
  entry->hello = GNUNET_copy_message (hello);
}

References add_entry(), cache, cache_lookup(), GNUNET_copy_message(), GNUNET_free, CacheEntry::hello, and peer_id.

Referenced by hello_update_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_stats_init()

void GST_stats_init

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Initialize logging CPU and IO statisticfs.

Checks the configuration for "STATS_DIR" and logs to a file in that directory. The file is name is generated from the hostname and the process's PID.

Definition at line 590 of file gnunet-service-testbed_cpustatus.c.

{
  char *hostname;
  char *stats_dir;
  char *fn;
  size_t len;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg, "testbed",
                                               "STATS_DIR", &stats_dir))
    return;
  len = GNUNET_OS_get_hostname_max_length ();
  hostname = GNUNET_malloc (len);
  if (0 != gethostname (hostname, len))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "gethostname");
    GNUNET_free (stats_dir);
    GNUNET_free (hostname);
    return;
  }
  fn = NULL;
  (void) GNUNET_asprintf (&fn, "%s/%.*s-%jd.dat", stats_dir, (int)len,
                          hostname, (intmax_t) getpid ());
  GNUNET_free (stats_dir);
  GNUNET_free (hostname);
  if (NULL == (bw = GNUNET_BIO_write_open_file (fn)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Cannot open %s for writing load statistics.  "
                   "Not logging load statistics\n"), fn);
    GNUNET_free (fn);
    return;
  }
  GNUNET_free (fn);
  sample_load_task_id = GNUNET_SCHEDULER_add_now (&sample_load_task, NULL);
#ifdef __linux__
  proc_stat = fopen ("/proc/stat", "r");
  if (NULL == proc_stat)
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                              "fopen", "/proc/stat");
#elif OSX
  initMachCpuStats ();
#endif
  updateUsage ();                /* initialize */
}

References _, bw, cfg, GNUNET_asprintf(), GNUNET_BIO_write_open_file(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_OK, GNUNET_OS_get_hostname_max_length, GNUNET_SCHEDULER_add_now(), hostname, len, sample_load_task(), sample_load_task_id, and updateUsage().

Referenced by testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_stats_destroy()

void GST_stats_destroy

(

void

)

Shutdown the status calls module.

Definition at line 641 of file gnunet-service-testbed_cpustatus.c.

{
  if (NULL == bw)
    return;
#ifdef __linux__
  if (proc_stat != NULL)
  {
    fclose (proc_stat);
    proc_stat = NULL;
  }
#elif OSX
  GNUNET_free (prev_cpu_load);
#endif
  if (NULL != sample_load_task_id)
  {
    GNUNET_SCHEDULER_cancel (sample_load_task_id);
    sample_load_task_id = NULL;
  }
  GNUNET_break (GNUNET_OK == GNUNET_BIO_write_close (bw, NULL));
  bw = NULL;
}

References bw, GNUNET_BIO_write_close(), GNUNET_break, GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), and sample_load_task_id.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

GST_config

struct GNUNET_CONFIGURATION_Handle* GST_config

extern

Our configuration.

Definition at line 39 of file gnunet-service-testbed.c.

Referenced by handle_init(), shutdown_task(), and testbed_run().

GST_context

struct Context* GST_context

extern

The master context; generated with the first INIT message.

Definition at line 44 of file gnunet-service-testbed.c.

Referenced by client_disconnect_cb(), GST_find_dest_route(), handle_add_host(), handle_barrier_cancel(), handle_barrier_init(), handle_barrier_status(), handle_init(), handle_link_controllers(), handle_peer_create(), handle_peer_start(), handle_peer_stop(), shutdown_task(), and update_peer_config().

fopcq_head

struct ForwardedOperationContext* fopcq_head

extern

DLL head for forwarded operation contexts.

Definition at line 54 of file gnunet-service-testbed.c.

Referenced by client_disconnect_cb(), forward_overlay_connect(), GST_clear_fopcq(), GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_notify_client_disconnect_oc(), GST_notify_client_disconnect_peers(), GST_process_next_focc(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_shutdown_peers(), and shutdown_peers_reply_cb().

fopcq_tail

struct ForwardedOperationContext* fopcq_tail

extern

DLL tail for forwarded operation contexts.

Definition at line 59 of file gnunet-service-testbed.c.

Referenced by forward_overlay_connect(), GST_clear_fopcq(), GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_process_next_focc(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_shutdown_peers(), and shutdown_peers_reply_cb().

GST_peer_list

struct Peer** GST_peer_list

extern

A list of peers we know about.

Definition at line 37 of file gnunet-service-testbed_peers.c.

Referenced by check_remote_overlay_connect(), cleanup_occ(), cleanup_prc(), forward_overlay_connect(), GST_destroy_peers(), GST_process_next_focc(), handle_manage_peer_service(), handle_overlay_connect(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_remote_overlay_connect(), occ_hello_sent_cb(), p2_transport_connect(), peer_list_add(), peer_list_remove(), and prc_stop_cb().

GST_host_list

struct GNUNET_TESTBED_Host** GST_host_list

extern

Array of hosts.

Definition at line 49 of file gnunet-service-testbed.c.

Referenced by forward_overlay_connect(), GST_queue_host_registration(), handle_link_controllers(), handle_overlay_connect(), handle_slave_get_config(), host_list_add(), hr_completion(), lcf_proc_task(), opstart_neighbour_conn(), register_host(), register_next_host(), shutdown_task(), slave_event_cb(), and slave_status_cb().

GST_opq_openfds

struct OperationQueue* GST_opq_openfds

extern

Operation queue for open file descriptors.

Definition at line 64 of file gnunet-service-testbed.c.

Referenced by GST_connection_pool_get_handle(), GST_neighbour_get_connection(), shutdown_task(), and testbed_run().

GST_timeout

struct GNUNET_TIME_Relative GST_timeout

extern

Timeout for operations which may take some time.

Definition at line 64 of file gnunet-service-testbed.c.

Referenced by forward_overlay_connect(), GST_process_next_focc(), handle_link_controllers(), handle_manage_peer_service(), handle_overlay_connect(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_remote_overlay_connect(), lcf_proc_task(), and testbed_run().

GST_peer_list_size

unsigned int GST_peer_list_size

extern

The size of the peer list.

Definition at line 79 of file gnunet-service-testbed.c.

Referenced by check_remote_overlay_connect(), GST_destroy_peers(), handle_manage_peer_service(), peer_list_add(), and peer_list_remove().

GST_num_local_peers

unsigned int GST_num_local_peers

extern

The current number of peers running locally under this controller.

Definition at line 42 of file gnunet-service-testbed_peers.c.

Referenced by peer_list_add(), and peer_list_remove().

GST_host_list_size

unsigned int GST_host_list_size

extern

The size of the host list.

Definition at line 74 of file gnunet-service-testbed.c.

Referenced by handle_link_controllers(), host_list_add(), and shutdown_task().

GST_stats_dir

char* GST_stats_dir

extern

The directory where to store load statistics data.