gnunet-service-testbed_peers.c File Reference

implementation of TESTBED service that deals with peer management More...

#include "gnunet-service-testbed.h"
#include "gnunet_arm_service.h"
#include <zlib.h>

Include dependency graph for gnunet-service-testbed_peers.c:

Go to the source code of this file.

Data Structures
struct	ManageServiceContext
	Context information to manage peers' services. More...
struct	PeerReconfigureContext
	Context information for peer re-configure operations. More...

Functions
static void	peer_list_add (struct Peer *peer)
	Adds a peer to the peer array. More...
static void	peer_list_remove (struct Peer *peer)
	Removes a the give peer from the peer array. More...
static void	peer_create_forward_timeout (void *cls)
	The task to be executed if the forwarded peer create operation has been timed out. More...
static void	peer_create_success_cb (void *cls, const struct GNUNET_MessageHeader *msg)
	Callback to be called when forwarded peer create operation is successfull. More...
void	GST_destroy_peer (struct Peer *peer)
	Function to destroy a peer. More...
static void	cleanup_mctx (struct ManageServiceContext *mctx)
	Cleanup the context information created for managing a peer's service. More...
static int	stop_peer (struct Peer *peer)
	Stops a peer. More...
static void	cleanup_prc (struct PeerReconfigureContext *prc)
	Cleans up the given PeerReconfigureContext. More...
void	GST_notify_client_disconnect_peers (struct GNUNET_SERVICE_Client *client)
	Notify peers subsystem that client disconnected. More...
static void	peer_destroy_success_cb (void *cls, const struct GNUNET_MessageHeader *msg)
	Callback to be called when forwarded peer destroy operation is successfull. 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...
static int	start_peer (struct Peer *peer)
	Stats a peer. 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_STOP_PEER messages. More...
void	handle_peer_get_config (void *cls, const struct GNUNET_TESTBED_PeerGetConfigurationMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION messages. More...
void	GST_free_prcq ()
	Cleans up the Peer reconfigure context list. More...
static char *	update_peer_config (struct Peer *peer, struct GNUNET_CONFIGURATION_Handle *cfg)
	Update peer configuration. More...
static void	prc_stop_cb (void *cls, struct GNUNET_TESTING_Peer *p, int success)
	Callback to inform whether the peer is running or stopped. 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 ()
	Frees the ManageServiceContext queue. More...
static const char *	arm_req_string (enum GNUNET_ARM_RequestStatus rs)
	Returns a string interpretation of rs. More...
static const char *	arm_ret_string (enum GNUNET_ARM_Result result)
	Returns a string interpretation of the result. More...
static void	service_manage_result_cb (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
	Function called in response to a start/stop request. 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...
void	GST_destroy_peers ()
	Stops and destroys all peers. More...
static void	shutdown_peers_reply_cb (void *cls, const struct GNUNET_MessageHeader *msg)
	The reply msg handler forwarded SHUTDOWN_PEERS operation. More...
void	handle_shutdown_peers (void *cls, const struct GNUNET_TESTBED_ShutdownPeersMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS messages. More...

Variables
struct Peer **	GST_peer_list
	A list of peers we know about. More...
unsigned int	GST_num_local_peers
	The current number of peers running locally under this controller. More...
static struct PeerReconfigureContext *	prc_head
	The DLL head for the peer reconfigure list. More...
static struct PeerReconfigureContext *	prc_tail
	The DLL tail for the peer reconfigure list. More...
static struct ManageServiceContext *	mctx_head
	DLL head for queue of manage service requests. More...
static struct ManageServiceContext *	mctx_tail
	DLL tail for queue of manage service requests. More...

Detailed Description

implementation of TESTBED service that deals with peer management

Author

Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Definition in file gnunet-service-testbed_peers.c.

Function Documentation

peer_list_add()

static void peer_list_add ( struct Peer *  peer )

static

Adds a peer to the peer array.

Parameters

peer	the peer to add

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

References GNUNET_assert, GNUNET_NO, GST_array_grow_large_enough, GST_num_local_peers, GST_peer_list_size, Peer::id, Peer::is_remote, and ManageServiceContext::peer.

Referenced by handle_peer_create(), and peer_create_success_cb().

{
  if (peer->id >= GST_peer_list_size)
    GST_array_grow_large_enough(GST_peer_list, GST_peer_list_size, peer->id);
  GNUNET_assert(NULL == GST_peer_list[peer->id]);
  GST_peer_list[peer->id] = peer;
  if (GNUNET_NO == peer->is_remote)
    GST_num_local_peers++;
}

Here is the caller graph for this function:

peer_list_remove()

static void peer_list_remove ( struct Peer *  peer )

static

Removes a the give peer from the peer array.

Parameters

peer	the peer to be removed

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

References GNUNET_NO, GNUNET_realloc, GST_num_local_peers, GST_peer_list_size, id, Peer::id, Peer::is_remote, and LIST_GROW_STEP.

Referenced by GST_destroy_peer().

{
  unsigned int orig_size;
  uint32_t id;

  if (GNUNET_NO == peer->is_remote)
    GST_num_local_peers--;
  GST_peer_list[peer->id] = NULL;
  orig_size = GST_peer_list_size;
  while (GST_peer_list_size >= LIST_GROW_STEP)
    {
      for (id = GST_peer_list_size - 1;
           (id >= GST_peer_list_size - LIST_GROW_STEP) && (id != UINT32_MAX);
           id--)
        if (NULL != GST_peer_list[id])
          break;
      if (id != ((GST_peer_list_size - LIST_GROW_STEP) - 1))
        break;
      GST_peer_list_size -= LIST_GROW_STEP;
    }
  if (orig_size == GST_peer_list_size)
    return;
  GST_peer_list =
    GNUNET_realloc(GST_peer_list,
                   sizeof(struct Peer *) * GST_peer_list_size);
}

Here is the caller graph for this function:

peer_create_forward_timeout()

static void peer_create_forward_timeout ( void *  cls )

static

The task to be executed if the forwarded peer create operation has been timed out.

Parameters

cls	the FowardedOperationContext

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

References ForwardedOperationContext::cls, GNUNET_free, and GST_forwarded_operation_timeout().

Referenced by handle_peer_create().

{
  struct ForwardedOperationContext *fopc = cls;

  GNUNET_free(fopc->cls);
  GST_forwarded_operation_timeout(fopc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

peer_create_success_cb()

static void peer_create_success_cb ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Callback to be called when forwarded peer create operation is successfull.

We have to relay the reply msg back to the client

Parameters

cls	ForwardedOperationContext
msg	the peer create success message

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

References ForwardedOperationContext::cls, GNUNET_assert, GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS, GST_forwarded_operation_reply_relay(), peer_list_add(), and GNUNET_MessageHeader::type.

Referenced by handle_peer_create().

{
  struct ForwardedOperationContext *fopc = cls;
  struct Peer *remote_peer;

  if (ntohs(msg->type) == GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS)
    {
      GNUNET_assert(NULL != fopc->cls);
      remote_peer = fopc->cls;
      peer_list_add(remote_peer);
    }
  GST_forwarded_operation_reply_relay(fopc,
                                      msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 258 of file gnunet-service-testbed_peers.c.

References Peer::details, GNUNET_break, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_NO, GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_stop(), GNUNET_YES, Peer::is_remote, Peer::local, peer_list_remove(), and Peer::reference_cnt.

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

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_mctx()

static void cleanup_mctx ( struct ManageServiceContext *  mctx )

static

Cleanup the context information created for managing a peer's service.

Parameters

mctx	the ManageServiceContext

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

References ManageServiceContext::ah, Peer::destroy_flag, ManageServiceContext::expired, GNUNET_ARM_disconnect(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_YES, GST_destroy_peer(), ManageServiceContext::peer, Peer::reference_cnt, and ManageServiceContext::service.

Referenced by GST_free_mctxq(), GST_notify_client_disconnect_peers(), and service_manage_result_cb().

{
  mctx->expired = GNUNET_YES;
  GNUNET_CONTAINER_DLL_remove(mctx_head,
                              mctx_tail,
                              mctx);
  GNUNET_ARM_disconnect(mctx->ah);
  GNUNET_assert(0 < mctx->peer->reference_cnt);
  mctx->peer->reference_cnt--;
  if ((GNUNET_YES == mctx->peer->destroy_flag) &&
      (0 == mctx->peer->reference_cnt))
    GST_destroy_peer(mctx->peer);
  GNUNET_free(mctx->service);
  GNUNET_free(mctx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

stop_peer()

static int stop_peer ( struct Peer *  peer )

static

Stops a peer.

Parameters

peer	the peer to stop

Returns

GNUNET_OK upon success; GNUNET_SYSERR upon failure

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

References Peer::details, GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_peer_kill(), Peer::is_remote, and Peer::local.

Referenced by cleanup_prc(), and handle_peer_stop().

{
  GNUNET_assert(GNUNET_NO == peer->is_remote);
  if (GNUNET_OK != GNUNET_TESTING_peer_kill(peer->details.local.peer))
    return GNUNET_SYSERR;
  peer->details.local.is_running = GNUNET_NO;
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_prc()

static void cleanup_prc ( struct PeerReconfigureContext *  prc )

static

Cleans up the given PeerReconfigureContext.

Parameters

prc	the PeerReconfigureContext

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

References PeerReconfigureContext::cfg, Peer::details, GNUNET_CONFIGURATION_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_TESTING_peer_stop_async_cancel(), Peer::local, ManageServiceContext::peer, PeerReconfigureContext::peer_id, stop_peer(), PeerReconfigureContext::stopped, and VALID_PEER_ID.

Referenced by GST_free_prcq(), GST_notify_client_disconnect_peers(), and prc_stop_cb().

{
  struct Peer *peer;

  if (VALID_PEER_ID(prc->peer_id))
    {
      peer = GST_peer_list [prc->peer_id];
      if (1 != prc->stopped)
        {
          GNUNET_TESTING_peer_stop_async_cancel(peer->details.local.peer);
          stop_peer(peer);      /* Stop the peer synchronously */
        }
    }
  if (NULL != prc->cfg)
    GNUNET_CONFIGURATION_destroy(prc->cfg);
  GNUNET_CONTAINER_DLL_remove(prc_head,
                              prc_tail,
                              prc);
  GNUNET_free(prc);
}

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 353 of file gnunet-service-testbed_peers.c.

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

Referenced by client_disconnect_cb().

{
  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);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

peer_destroy_success_cb()

static void peer_destroy_success_cb ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Callback to be called when forwarded peer destroy operation is successfull.

We have to relay the reply msg back to the client

Parameters

cls	ForwardedOperationContext
msg	the peer create success message

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

References ForwardedOperationContext::cls, Peer::destroy_flag, GNUNET_assert, GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, GNUNET_YES, GST_destroy_peer(), GST_forwarded_operation_reply_relay(), Peer::reference_cnt, and GNUNET_MessageHeader::type.

Referenced by handle_peer_destroy().

{
  struct ForwardedOperationContext *fopc = cls;
  struct Peer *remote_peer;

  if (GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS ==
      ntohs(msg->type))
    {
      remote_peer = fopc->cls;
      GNUNET_assert(NULL != remote_peer);
      remote_peer->destroy_flag = GNUNET_YES;
      if (0 == remote_peer->reference_cnt)
        GST_destroy_peer(remote_peer);
    }
  GST_forwarded_operation_reply_relay(fopc,
                                      msg);
}

Here is the call graph for this function:

Here is the caller 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 423 of file gnunet-service-testbed_peers.c.

References GNUNET_OK.

{
  return GNUNET_OK; /* checked later */
}

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 437 of file gnunet-service-testbed_peers.c.

References cfg, ManageServiceContext::client, ForwardedOperationContext::client, ForwardedOperationContext::cls, Slave::controller, Route::dest, Peer::details, 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, GNUNET_TESTBED_PeerCreateMessage::header, GNUNET_TESTBED_PeerCreateMessage::host_id, Context::host_id, Peer::id, Peer::is_remote, Peer::local, LOG, LOG_DEBUG, OP_PEER_CREATE, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerCreateMessage::operation_id, GNUNET_TESTBED_PeerCreateSuccessEventMessage::operation_id, ManageServiceContext::peer, peer_create_forward_timeout(), peer_create_success_cb(), peer_id, GNUNET_TESTBED_PeerCreateMessage::peer_id, GNUNET_TESTBED_PeerCreateSuccessEventMessage::peer_id, peer_list_add(), Peer::remote, Context::system, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

{
  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);
}

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 569 of file gnunet-service-testbed_peers.c.

References ManageServiceContext::client, ForwardedOperationContext::client, ForwardedOperationContext::cls, Slave::controller, Peer::destroy_flag, Peer::details, 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_send_operation_fail_msg(), GST_send_operation_success_msg(), GST_timeout, GNUNET_TESTBED_PeerDestroyMessage::header, Peer::is_remote, LOG, LOG_DEBUG, OP_PEER_DESTROY, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerDestroyMessage::operation_id, ManageServiceContext::peer, peer_destroy_success_cb(), peer_id, GNUNET_TESTBED_PeerDestroyMessage::peer_id, Peer::reference_cnt, Peer::remote, Peer::slave, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

{
  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 destory 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 destory 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);
}

Here is the call graph for this function:

start_peer()

static int start_peer ( struct Peer *  peer )

static

Stats a peer.

Parameters

peer	the peer to start

Returns

GNUNET_OK upon success; GNUNET_SYSERR upon failure

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

References Peer::details, GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_peer_start(), GNUNET_YES, Peer::is_remote, and Peer::local.

Referenced by handle_peer_start(), and prc_stop_cb().

{
  GNUNET_assert(GNUNET_NO == peer->is_remote);
  if (GNUNET_OK != GNUNET_TESTING_peer_start(peer->details.local.peer))
    return GNUNET_SYSERR;
  peer->details.local.is_running = GNUNET_YES;
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller 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.

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages.

Parameters

cls	identification of the client
msg	the actual message

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

References ManageServiceContext::client, ForwardedOperationContext::client, Slave::controller, Peer::details, 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_send_operation_fail_msg(), GST_timeout, GNUNET_TESTBED_PeerStartMessage::header, Context::host_id, GNUNET_TESTBED_PeerEventMessage::host_id, Peer::is_remote, LOG, OP_PEER_START, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerStartMessage::operation_id, GNUNET_TESTBED_PeerEventMessage::operation_id, ManageServiceContext::peer, peer_id, GNUNET_TESTBED_PeerStartMessage::peer_id, GNUNET_TESTBED_PeerEventMessage::peer_id, Peer::remote, Peer::slave, start_peer(), ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

{
  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);
}

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_STOP_PEER messages.

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_DESTROYPEER messages.

Parameters

cls	identification of the client
msg	the actual message

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

References ManageServiceContext::client, ForwardedOperationContext::client, Slave::controller, Peer::details, 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_send_operation_fail_msg(), GST_timeout, GNUNET_TESTBED_PeerStopMessage::header, Context::host_id, GNUNET_TESTBED_PeerEventMessage::host_id, Peer::is_remote, Peer::local, LOG, OP_PEER_STOP, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerStopMessage::operation_id, GNUNET_TESTBED_PeerEventMessage::operation_id, ManageServiceContext::peer, peer_id, GNUNET_TESTBED_PeerStopMessage::peer_id, GNUNET_TESTBED_PeerEventMessage::peer_id, Peer::remote, Peer::slave, stop_peer(), ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

{
  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);
}

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_GET_PEER_INFORMATION messages.

Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG messages.

Parameters

cls	identification of the client
msg	the actual message

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

References ManageServiceContext::client, 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_send_operation_fail_msg(), GST_timeout, GNUNET_TESTBED_PeerGetConfigurationMessage::header, Peer::is_remote, LOG_DEBUG, OP_PEER_INFO, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerGetConfigurationMessage::operation_id, GNUNET_TESTBED_PeerConfigurationInformationMessage::operation_id, ManageServiceContext::peer, peer_id, GNUNET_TESTBED_PeerGetConfigurationMessage::peer_id, GNUNET_TESTBED_PeerConfigurationInformationMessage::peer_id, GNUNET_TESTBED_PeerConfigurationInformationMessage::peer_identity, Peer::remote, Peer::slave, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, and VALID_PEER_ID.

{
  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);
}

Here is the call graph for this function:

GST_free_prcq()

void GST_free_prcq

(

void

)

Cleans up the Peer reconfigure context list.

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

References cleanup_prc().

Referenced by shutdown_task().

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

Here is the call graph for this function:

Here is the caller graph for this function:

update_peer_config()

static char* update_peer_config ( struct Peer *  peer, struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Update peer configuration.

Parameters

peer	the peer to update
cfg	the new configuration

Returns

error message (freshly allocated); NULL upon success

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

References cfg, Peer::details, GNUNET_CONFIGURATION_destroy(), GNUNET_TESTING_peer_configure(), GNUNET_TESTING_peer_destroy(), GST_context, Peer::id, Peer::local, and Context::system.

Referenced by handle_peer_reconfigure(), and prc_stop_cb().

{
  char *emsg;

  GNUNET_TESTING_peer_destroy(peer->details.local.peer);
  GNUNET_CONFIGURATION_destroy(peer->details.local.cfg);
  peer->details.local.cfg = cfg;
  emsg = NULL;
  peer->details.local.peer
    = GNUNET_TESTING_peer_configure(GST_context->system,
                                    peer->details.local.cfg,
                                    peer->id,
                                    NULL /* Peer id */,
                                    &emsg);
  return emsg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

prc_stop_cb()

static void prc_stop_cb ( void *  cls, struct GNUNET_TESTING_Peer *  p, int  success  )

static

Callback to inform whether the peer is running or stopped.

Parameters

cls	the closure given to GNUNET_TESTING_peer_stop_async()
p	the respective peer whose status is being reported
success	GNUNET_YES if the peer is stopped; GNUNET_SYSERR upon any error

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

References PeerReconfigureContext::cfg, cleanup(), cleanup_prc(), PeerReconfigureContext::client, GNUNET_assert, GNUNET_NO, GNUNET_OK, GST_send_operation_fail_msg(), GST_send_operation_success_msg(), Peer::is_remote, PeerReconfigureContext::op_id, ManageServiceContext::peer, PeerReconfigureContext::peer_id, start_peer(), PeerReconfigureContext::stopped, update_peer_config(), and VALID_PEER_ID.

Referenced by handle_peer_reconfigure().

{
  struct PeerReconfigureContext *prc = cls;
  struct Peer *peer;
  char *emsg;

  GNUNET_assert(VALID_PEER_ID(prc->peer_id));
  peer = GST_peer_list [prc->peer_id];
  GNUNET_assert(GNUNET_NO == peer->is_remote);
  emsg = update_peer_config(peer, prc->cfg);
  prc->cfg = NULL;
  prc->stopped = 1;
  if (NULL != emsg)
    {
      GST_send_operation_fail_msg(prc->client,
                                  prc->op_id,
                                  emsg);
      goto cleanup;
    }
  if (GNUNET_OK != start_peer(peer))
    {
      GST_send_operation_fail_msg(prc->client,
                                  prc->op_id,
                                  "Failed to start reconfigured peer");
      goto cleanup;
    }
  GST_send_operation_success_msg(prc->client,
                                 prc->op_id);

cleanup:
  cleanup_prc(prc);
  return;
}

Here is the call graph for this function:

Here is the caller 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 975 of file gnunet-service-testbed_peers.c.

References GNUNET_OK.

{
  return GNUNET_OK; /* checked later */
}

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 asyncronously, destroy it and create it again with the new configuration.

Parameters

cls	identification of the client
msg	the actual message

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

References cfg, PeerReconfigureContext::cfg, ManageServiceContext::client, ForwardedOperationContext::client, PeerReconfigureContext::client, Peer::destroy_flag, Peer::details, fopcq_head, fopcq_tail, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_free_non_null, 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_send_operation_fail_msg(), GST_send_operation_success_msg(), GST_timeout, GNUNET_TESTBED_PeerReconfigureMessage::header, Peer::is_remote, Peer::local, LOG, LOG_DEBUG, ManageServiceContext::op_id, PeerReconfigureContext::op_id, OP_PEER_RECONFIGURE, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_PeerReconfigureMessage::operation_id, ManageServiceContext::peer, peer_id, PeerReconfigureContext::peer_id, GNUNET_TESTBED_PeerReconfigureMessage::peer_id, prc_stop_cb(), Peer::reference_cnt, Peer::remote, ForwardedOperationContext::timeout_task, ForwardedOperationContext::type, update_peer_config(), and VALID_PEER_ID.

{
  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_non_null(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);
}

Here is the call graph for this function:

GST_free_mctxq()

void GST_free_mctxq

(

void

)

Frees the ManageServiceContext queue.

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

References cleanup_mctx().

Referenced by handle_shutdown_peers(), and shutdown_task().

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

Here is the call graph for this function:

Here is the caller graph for this function:

arm_req_string()

static const char* arm_req_string ( enum GNUNET_ARM_RequestStatus  rs )

static

Returns a string interpretation of rs.

Parameters

rs	the request status from ARM

Returns

a string interpretation of the request status

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

References _, GNUNET_ARM_REQUEST_DISCONNECTED, and GNUNET_ARM_REQUEST_SENT_OK.

Referenced by service_manage_result_cb().

{
  switch (rs)
    {
    case GNUNET_ARM_REQUEST_SENT_OK:
      return _("Message was sent successfully");

    case GNUNET_ARM_REQUEST_DISCONNECTED:
      return _("We disconnected from ARM before we could send a request");
    }
  return _("Unknown request status");
}

Here is the caller graph for this function:

arm_ret_string()

static const char* arm_ret_string ( enum GNUNET_ARM_Result  result )

static

Returns a string interpretation of the result.

Parameters

result

the arm result

Returns

a string interpretation

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

References _, GNUNET_ARM_RESULT_IN_SHUTDOWN, GNUNET_ARM_RESULT_IS_NOT_KNOWN, GNUNET_ARM_RESULT_IS_STARTED_ALREADY, GNUNET_ARM_RESULT_IS_STARTING_ALREADY, GNUNET_ARM_RESULT_IS_STOPPED_ALREADY, GNUNET_ARM_RESULT_IS_STOPPING_ALREADY, GNUNET_ARM_RESULT_START_FAILED, GNUNET_ARM_RESULT_STARTING, GNUNET_ARM_RESULT_STOPPED, and GNUNET_ARM_RESULT_STOPPING.

Referenced by service_manage_result_cb().

{
  switch (result)
    {
    case GNUNET_ARM_RESULT_STOPPED:
      return _("%s is stopped");

    case GNUNET_ARM_RESULT_STARTING:
      return _("%s is starting");

    case GNUNET_ARM_RESULT_STOPPING:
      return _("%s is stopping");

    case GNUNET_ARM_RESULT_IS_STARTING_ALREADY:
      return _("%s is starting already");

    case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY:
      return _("%s is stopping already");

    case GNUNET_ARM_RESULT_IS_STARTED_ALREADY:
      return _("%s is started already");

    case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY:
      return _("%s is stopped already");

    case GNUNET_ARM_RESULT_IS_NOT_KNOWN:
      return _("%s service is not known to ARM");

    case GNUNET_ARM_RESULT_START_FAILED:
      return _("%s service failed to start");

    case GNUNET_ARM_RESULT_IN_SHUTDOWN:
      return _("%s service can't be started because ARM is shutting down");
    }
  return _("%.s Unknown result code.");
}

Here is the caller graph for this function:

service_manage_result_cb()

static void service_manage_result_cb ( void *  cls, enum GNUNET_ARM_RequestStatus  rs, enum GNUNET_ARM_Result  result  )

static

Function called in response to a start/stop request.

Will be called when request was not sent successfully, or when a reply comes. If the request was not sent successfully, rs will indicate that, and result will be undefined.

Parameters

cls	ManageServiceContext
rs	status of the request
result	result of the operation

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

References arm_req_string(), arm_ret_string(), cleanup_mctx(), ManageServiceContext::client, ManageServiceContext::expired, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_STARTED_ALREADY, GNUNET_ARM_RESULT_IS_STARTING_ALREADY, GNUNET_ARM_RESULT_IS_STOPPED_ALREADY, GNUNET_ARM_RESULT_IS_STOPPING_ALREADY, GNUNET_ARM_RESULT_STARTING, GNUNET_ARM_RESULT_STOPPED, GNUNET_ARM_RESULT_STOPPING, GNUNET_asprintf(), GNUNET_free_non_null, GNUNET_YES, GST_send_operation_fail_msg(), GST_send_operation_success_msg(), Peer::id, LOG_DEBUG, ManageServiceContext::op_id, ManageServiceContext::peer, ret, ManageServiceContext::service, and ManageServiceContext::start.

Referenced by handle_manage_peer_service().

{
  struct ManageServiceContext *mctx = cls;
  char *emsg;

  emsg = NULL;
  if (GNUNET_YES == mctx->expired)
    return;
  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
    {
      GNUNET_asprintf(&emsg,
                      "Error communicating with Peer %u's ARM: %s",
                      mctx->peer->id,
                      arm_req_string(rs));
      goto ret;
    }
  if (1 == mctx->start)
    goto service_start_check;
  if (!((GNUNET_ARM_RESULT_STOPPED == result)
        || (GNUNET_ARM_RESULT_STOPPING == result)
        || (GNUNET_ARM_RESULT_IS_STOPPING_ALREADY == result)
        || (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY == result)))
    {
      /* stopping a service failed */
      GNUNET_asprintf(&emsg,
                      arm_ret_string(result),
                      mctx->service);
      goto ret;
    }
  /* service stopped successfully */
  goto ret;

service_start_check:
  if (!((GNUNET_ARM_RESULT_STARTING == result)
        || (GNUNET_ARM_RESULT_IS_STARTING_ALREADY == result)
        || (GNUNET_ARM_RESULT_IS_STARTED_ALREADY == result)))
    {
      /* starting a service failed */
      GNUNET_asprintf(&emsg,
                      arm_ret_string(result),
                      mctx->service);
      goto ret;
    }
  /* service started successfully */

ret:
  if (NULL != emsg)
    {
      LOG_DEBUG("%s\n", emsg);
      GST_send_operation_fail_msg(mctx->client,
                                  mctx->op_id,
                                  emsg);
    }
  else
    GST_send_operation_success_msg(mctx->client,
                                   mctx->op_id);
  GNUNET_free_non_null(emsg);
  cleanup_mctx(mctx);
}

Here is the call graph for this function:

Here is the caller 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 1273 of file gnunet-service-testbed_peers.c.

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTBED_ManagePeerServiceMessage::header, ManageServiceContext::service, GNUNET_MessageHeader::size, and GNUNET_TESTBED_ManagePeerServiceMessage::start.

{
  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;
}

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.

Handler for GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE message.

Parameters

cls	identification of client
msg	the actual message

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

References ManageServiceContext::ah, ManageServiceContext::client, ForwardedOperationContext::client, ForwardedOperationContext::cls, Peer::details, 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_size, GST_send_operation_fail_msg(), GST_timeout, GNUNET_TESTBED_ManagePeerServiceMessage::header, Peer::is_remote, Peer::local, LOG, LOG_DEBUG, ManageServiceContext::op_id, OP_MANAGE_SERVICE, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_ManagePeerServiceMessage::operation_id, ManageServiceContext::peer, peer_id, GNUNET_TESTBED_ManagePeerServiceMessage::peer_id, Peer::reference_cnt, Peer::remote, ManageServiceContext::service, service_manage_result_cb(), ManageServiceContext::start, GNUNET_TESTBED_ManagePeerServiceMessage::start, ForwardedOperationContext::timeout_task, and ForwardedOperationContext::type.

{
  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 destory 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);
}

Here is the call graph for this function:

GST_destroy_peers()

void GST_destroy_peers

(

void

)

Stops and destroys all peers.

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

References Peer::destroy_flag, Peer::details, GNUNET_break, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_free_non_null, GNUNET_NO, GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_kill(), GNUNET_TESTING_peer_wait(), GNUNET_YES, GST_peer_list_size, id, Peer::is_remote, Peer::local, ManageServiceContext::peer, and Peer::reference_cnt.

Referenced by handle_shutdown_peers(), and shutdown_task().

{
  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_non_null(GST_peer_list);
  GST_peer_list = NULL;
  GST_peer_list_size = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_peers_reply_cb()

static void shutdown_peers_reply_cb ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

The reply msg handler forwarded SHUTDOWN_PEERS operation.

Checks if a success reply is received from all clients and then sends the success message to the client

Parameters

cls	ForwardedOperationContext
msg	the message to relay

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

References ForwardedOperationContext::client, ForwardedOperationContext::cls, fopcq_head, fopcq_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, GNUNET_YES, GST_send_operation_fail_msg(), GST_send_operation_success_msg(), HandlerContext_ShutdownPeers::nslaves, ForwardedOperationContext::operation_id, HandlerContext_ShutdownPeers::timeout, and GNUNET_MessageHeader::type.

Referenced by handle_shutdown_peers().

{
  struct ForwardedOperationContext *fo_ctxt = cls;
  struct HandlerContext_ShutdownPeers *hc;

  hc = fo_ctxt->cls;
  GNUNET_assert(0 < hc->nslaves);
  hc->nslaves--;
  if (GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS !=
      ntohs(msg->type))
    hc->timeout = GNUNET_YES;
  if (0 == hc->nslaves)
    {
      if (GNUNET_YES == hc->timeout)
        GST_send_operation_fail_msg(fo_ctxt->client,
                                    fo_ctxt->operation_id,
                                    "Timeout at a slave controller");
      else
        GST_send_operation_success_msg(fo_ctxt->client,
                                       fo_ctxt->operation_id);
      GNUNET_free(hc);
      hc = NULL;
    }
  GNUNET_CONTAINER_DLL_remove(fopcq_head,
                              fopcq_tail,
                              fo_ctxt);
  GNUNET_free(fo_ctxt);
}

Here is the call graph for this function:

Here is the caller 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 1505 of file gnunet-service-testbed_peers.c.

References ManageServiceContext::client, 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, GNUNET_TESTBED_ShutdownPeersMessage::header, LOG_DEBUG, HandlerContext_ShutdownPeers::nslaves, ManageServiceContext::op_id, OP_SHUTDOWN_PEERS, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, GNUNET_TESTBED_ShutdownPeersMessage::operation_id, shutdown_peers_reply_cb(), and ForwardedOperationContext::type.

{
  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);
}

Here is the call graph for this function:

Variable Documentation

GST_peer_list

struct Peer** GST_peer_list

A list of peers we know about.

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

Referenced by check_remote_overlay_connect(), cleanup_occ(), forward_overlay_connect(), GST_process_next_focc(), handle_overlay_connect(), handle_remote_overlay_connect(), occ_hello_sent_cb(), and p2_transport_connect().

GST_num_local_peers

unsigned int GST_num_local_peers

The current number of peers running locally under this controller.

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

Referenced by peer_list_add(), and peer_list_remove().

prc_head

struct PeerReconfigureContext* prc_head

static

The DLL head for the peer reconfigure list.

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

prc_tail

struct PeerReconfigureContext* prc_tail

static

The DLL tail for the peer reconfigure list.

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

mctx_head

struct ManageServiceContext* mctx_head

static

DLL head for queue of manage service requests.

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

mctx_tail

struct ManageServiceContext* mctx_tail

static

DLL tail for queue of manage service requests.

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