testing_core_cmd_connect.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_lib.h"
#include "gnunet_testing_arm_lib.h"
#include "gnunet_testing_core_lib.h"
#include "gnunet_core_service.h"

Include dependency graph for testing_core_cmd_connect.c:

Go to the source code of this file.

Macros
#define	MTYPE   12345
#define	LOG(kind, ...)    GNUNET_log_from (kind, "testing-core-connect", __VA_ARGS__)
	Generic logging shortcut. More...

Functions
static void	handle_test (void *cls, const struct GNUNET_TESTING_CORE_Message *msg)
static enum GNUNET_GenericReturnValue	connect_traits (void *cls, const void **ret, const char *trait, unsigned int index)
	This function prepares an array with traits. More...
static void	init_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
static void *	connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer_id, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
static void	disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
static void	exec_connect_run (void *cls, struct GNUNET_TESTING_Interpreter *is)
static void	exec_connect_cleanup (void *cls)
const struct GNUNET_TESTING_Command	GNUNET_TESTING_CORE_cmd_connect (const char *label, const char *node_id, char *arm_service_label)

Macro Definition Documentation

MTYPE

#define MTYPE   12345

Definition at line 38 of file testing_core_cmd_connect.c.

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "testing-core-connect", __VA_ARGS__)

Generic logging shortcut.

Definition at line 43 of file testing_core_cmd_connect.c.

Function Documentation

handle_test()

static void handle_test ( void *  cls, const struct GNUNET_TESTING_CORE_Message *  msg  )

static

Definition at line 48 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_Channel *channel = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "Received message (%" PRIu64 ", %" PRIu64 ", %s) - going to call handlers\n",
      GNUNET_ntohll (msg->id),
      GNUNET_ntohll (msg->batch),
      msg->node_id);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "  (We: %s)\n", channel->connect_state->node_id);
 
  if (0 == strncmp (msg->node_id, channel->connect_state->node_id, NODE_ID_LEN))
    LOG (GNUNET_ERROR_TYPE_ERROR,
        "We received a message from ourself!\n");
 
  for (uint32_t i = 0; i < channel->connect_state->recv_handlers_len; i++)
  {
    if (NULL == channel->connect_state->recv_handlers[i]) continue;
    // FIXME: set cls per handler
    channel->connect_state->recv_handlers[i] (
        channel->connect_state->recv_handlers_cls,
        channel,
        msg);
  }
 
  // FIXME do we need to call something like the below?
  //GNUNET_CORE_UNDERLAY_DUMMY_receive_continue (channel->connect_state->h,
  //                                             channel->mq);
}

References GNUNET_TESTING_CORE_Channel::connect_state, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ntohll(), LOG, msg, GNUNET_TESTING_CORE_ConnectState::node_id, NODE_ID_LEN, GNUNET_TESTING_CORE_ConnectState::recv_handlers, GNUNET_TESTING_CORE_ConnectState::recv_handlers_cls, and GNUNET_TESTING_CORE_ConnectState::recv_handlers_len.

Here is the call graph for this function:

connect_traits()

static enum GNUNET_GenericReturnValue connect_traits ( void *  cls, const void **  ret, const char *  trait, unsigned int  index  )

static

This function prepares an array with traits.

Definition at line 83 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
  struct GNUNET_TESTING_Trait traits[] = {
    GNUNET_CORE_TESTING_make_trait_connect (connect_state),
    GNUNET_TESTING_trait_end ()
  };
 
  return GNUNET_TESTING_get_trait (traits,
                                   ret,
                                   trait,
                                   index);
}

References GNUNET_CORE_TESTING_make_trait_connect(), GNUNET_TESTING_get_trait(), GNUNET_TESTING_trait_end(), GNUNET_TESTING_Trait::index, ret, and traits().

Referenced by GNUNET_TESTING_CORE_cmd_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

init_cb()

static void init_cb ( void *  cls, const struct GNUNET_PeerIdentity *  my_identity  )

static

Definition at line 102 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "Connected to core, own pid: %s\n",
      GNUNET_i2s (my_identity));
  GNUNET_memcpy (&connect_state->peer_id, my_identity, sizeof (struct GNUNET_PeerIdentity));
  GNUNET_TESTING_async_finish (&connect_state->ac);
  // TODO we could finish connect at the first incoming connection
}

References GNUNET_TESTING_CORE_ConnectState::ac, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcpy, GNUNET_TESTING_async_finish(), LOG, my_identity, and GNUNET_TESTING_CORE_ConnectState::peer_id.

Referenced by exec_connect_run().

Here is the call graph for this function:

Here is the caller graph for this function:

connect_cb()

static void * connect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer_id, struct GNUNET_MQ_Handle *  mq, enum GNUNET_CORE_PeerClass  class  )

static

Definition at line 117 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
  struct GNUNET_TESTING_CORE_Channel *channel;
  (void) class; // unused
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "A new connection was established with peer %s\n",
      GNUNET_i2s (peer_id));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "  (us: %s)\n",
      GNUNET_i2s (&connect_state->peer_id));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "size of connect_state: %lu of channel: %lu\n",
      sizeof (struct GNUNET_TESTING_CORE_ConnectState),
      sizeof (struct GNUNET_TESTING_CORE_Channel));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "memcmp: %u\n",
      GNUNET_memcmp (&connect_state->peer_id, peer_id));
  if (0 == GNUNET_memcmp (&connect_state->peer_id, peer_id))
    LOG (GNUNET_ERROR_TYPE_DEBUG,
        "  (That's us - connection was established to ourself)\n");
 
  channel = GNUNET_new (struct GNUNET_TESTING_CORE_Channel);
  channel->connect_state = connect_state;
  channel->mq = mq;
  GNUNET_memcpy (&channel->peer_id, peer_id, sizeof (struct GNUNET_PeerIdentity));
  if (0 != GNUNET_memcmp (&connect_state->peer_id, peer_id))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Inserting channel into list\n");
    if ((NULL != connect_state->channels_head) &&
        (NULL != connect_state->channels_tail))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Peer at list head: %s\n",
          GNUNET_i2s (&connect_state->channels_head->peer_id));
      LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Peer at list tail: %s\n",
          GNUNET_i2s (&connect_state->channels_tail->peer_id));
    }
    else
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
          "empty list\n");
    }
    GNUNET_CONTAINER_DLL_insert (connect_state->channels_head,
                                 connect_state->channels_tail,
                                 channel);
  }
 
  /* Call connect handlers from test */
  if (0 != GNUNET_memcmp (&connect_state->peer_id, peer_id))
    for (uint32_t i = 0; i < connect_state->connect_cbs_len; i++)
    {
      // TODO check if we really want to pass everything as-is
      struct GNUNET_TESTING_CORE_ConnectCb *connect_cb_struct =
        &connect_state->connect_cbs[i];
      // FIXME this might return something, but the implemented function also
      // returns nothing
      connect_cb_struct->callback (connect_cb_struct->cls,
                                   peer_id,
                                   mq);
    }
 
  //if ((connect_state->num_channels_target == connect_state->channels_len) &&
  //    (GNUNET_NO == connect_state->finished))
  //{
  //  LOG (GNUNET_ERROR_TYPE_DEBUG, "(post connect_cb _async_finish)\n");
  //  GNUNET_TESTING_async_finish (&connect_state->ac);
  //  connect_state->finished = GNUNET_YES;
  //}
  //LOG (GNUNET_ERROR_TYPE_DEBUG,
  //    "(post connect_cb - %u of %u)\n",
  //    connect_state->channels_len,
  //    connect_state->num_channels_target);
 
  return channel;
}

References GNUNET_TESTING_CORE_ConnectCb::callback, GNUNET_TESTING_CORE_ConnectState::channels_head, GNUNET_TESTING_CORE_ConnectState::channels_tail, GNUNET_TESTING_CORE_ConnectCb::cls, GNUNET_TESTING_CORE_ConnectState::connect_cbs, GNUNET_TESTING_CORE_ConnectState::connect_cbs_len, GNUNET_TESTING_CORE_Channel::connect_state, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcmp, GNUNET_memcpy, GNUNET_new, LOG, mq, GNUNET_TESTING_CORE_Channel::mq, peer_id, GNUNET_TESTING_CORE_Channel::peer_id, and GNUNET_TESTING_CORE_ConnectState::peer_id.

Referenced by exec_connect_run(), GNUNET_SERVICE_register_(), GNUNET_SERVICE_run_(), and GNUNET_SERVICE_start().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect_cb()

static void disconnect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  peer_cls  )

static

Remove the closed channel:

1. find the (index of the) closed channel
2. copy all following channel one to the front

Definition at line 203 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
  struct GNUNET_TESTING_CORE_Channel *channel = peer_cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "from notify_disconnect_cb()\n");
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "Channel from peer %s (peer_cls) disconnects\n",
      GNUNET_i2s (&channel->peer_id));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "  %s (arg)\n",
      GNUNET_i2s (peer));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "  (we are %s)\n",
      GNUNET_i2s (&connect_state->peer_id));
  //if (NULL != channel->next)
  if (0 != GNUNET_memcmp (&connect_state->peer_id, peer))
  {
    /* this channel might not be in the list */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "removing channel from list\n");
    GNUNET_CONTAINER_DLL_remove (connect_state->channels_head,
                                 connect_state->channels_tail,
                                 channel);
  }
  GNUNET_free (channel);
}

References GNUNET_TESTING_CORE_ConnectState::channels_head, GNUNET_TESTING_CORE_ConnectState::channels_tail, GNUNET_TESTING_CORE_Channel::connect_state, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_memcmp, LOG, GNUNET_TESTING_CORE_Channel::peer_id, and GNUNET_TESTING_CORE_ConnectState::peer_id.

Referenced by exec_connect_run(), GNUNET_SERVICE_register_(), GNUNET_SERVICE_run_(), and GNUNET_SERVICE_start().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_connect_run()

static void exec_connect_run ( void *  cls, struct GNUNET_TESTING_Interpreter *  is  )

static

Definition at line 240 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
  const struct GNUNET_TESTING_Command *arm_cmd;
  struct GNUNET_MQ_MessageHandler handlers[] =
  {
    GNUNET_MQ_hd_fixed_size (test, MTYPE, struct GNUNET_TESTING_CORE_Message, NULL),
    GNUNET_MQ_handler_end ()
  };
  const struct GNUNET_CORE_ServiceInfo service_info =
  {
    .service = GNUNET_CORE_SERVICE_TEST,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "(%s) Going to connect to core\n",
      connect_state->node_id);
 
  arm_cmd = GNUNET_TESTING_interpreter_lookup_command (
        is,
        connect_state->arm_service_label);
  if (NULL == arm_cmd)
    GNUNET_TESTING_FAIL (is);
  if (GNUNET_OK !=
      GNUNET_TESTING_ARM_get_trait_config (
        arm_cmd,
        &connect_state->cfg))
    GNUNET_TESTING_FAIL (is);
 
  connect_state->h = GNUNET_CORE_connect (connect_state->cfg,
                                          connect_state, // cls
                                          init_cb,
                                          connect_cb,
                                          disconnect_cb,
                                          handlers,
                                          &service_info);
 
}

References GNUNET_TESTING_CORE_ConnectState::arm_service_label, GNUNET_TESTING_CORE_ConnectState::cfg, connect_cb(), disconnect_cb(), GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_TEST, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_OK, GNUNET_TESTING_FAIL, GNUNET_TESTING_interpreter_lookup_command(), GNUNET_TESTING_CORE_ConnectState::h, handlers, init_cb(), is, LOG, MTYPE, GNUNET_TESTING_CORE_ConnectState::node_id, and GNUNET_CORE_ServiceInfo::service.

Referenced by GNUNET_TESTING_CORE_cmd_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_connect_cleanup()

static void exec_connect_cleanup ( void *  cls )

static

Definition at line 285 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
 
  GNUNET_assert (NULL != connect_state->h);
  GNUNET_CORE_disconnect (connect_state->h);
  // TODO cleanup!
}

References GNUNET_assert, GNUNET_CORE_disconnect(), and GNUNET_TESTING_CORE_ConnectState::h.

Referenced by GNUNET_TESTING_CORE_cmd_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_CORE_cmd_connect()

const struct GNUNET_TESTING_Command GNUNET_TESTING_CORE_cmd_connect	(	const char *	label,
		const char *	node_id,
		char *	arm_service_label
	)

Definition at line 297 of file testing_core_cmd_connect.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state;
 
  // TODO get handler from caller to call on new connections
 
  connect_state = GNUNET_new (struct GNUNET_TESTING_CORE_ConnectState);
  connect_state->node_id = GNUNET_strdup (node_id);
  connect_state->arm_service_label = GNUNET_strdup (arm_service_label);
  connect_state->recv_handlers_len = 0;
  connect_state->recv_handlers =
    GNUNET_new_array (connect_state->recv_handlers_len,
                      GNUNET_TESTING_CORE_handle_msg);
  connect_state->connect_cbs_len = 0;
  connect_state->connect_cbs =
    GNUNET_new_array (connect_state->connect_cbs_len,
                      struct GNUNET_TESTING_CORE_ConnectCb);
  connect_state->finished = GNUNET_NO;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "(Setting up _cmd_connect)\n");
  return GNUNET_TESTING_command_new_ac ( // TODO make this sync?
      connect_state, // state
      label,
      &exec_connect_run,
      &exec_connect_cleanup,
      &connect_traits,
      &connect_state->ac); // TODO make this sync?
}

References GNUNET_TESTING_CORE_ConnectState::ac, GNUNET_TESTING_CORE_ConnectState::arm_service_label, GNUNET_TESTING_CORE_ConnectState::connect_cbs, GNUNET_TESTING_CORE_ConnectState::connect_cbs_len, connect_traits(), exec_connect_cleanup(), exec_connect_run(), GNUNET_TESTING_CORE_ConnectState::finished, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_new_array, GNUNET_NO, GNUNET_strdup, GNUNET_TESTING_command_new_ac(), LOG, GNUNET_TESTING_CORE_ConnectState::node_id, GNUNET_TESTING_CORE_ConnectState::recv_handlers, and GNUNET_TESTING_CORE_ConnectState::recv_handlers_len.

Here is the call graph for this function: