testing_core_cmd_send.c File Reference

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

Include dependency graph for testing_core_cmd_send.c:

Go to the source code of this file.

Data Structures
struct	SendState
	State for the 'send' command. More...

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

Functions
static void *	connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer_id, struct GNUNET_MQ_Handle *mq)
static void	cleanup_callbacks (struct SendState *send_state)
static void	send_messages (struct SendState *send_state)
static void	exec_send_run (void *cls, struct GNUNET_TESTING_Interpreter *is)
static void	exec_send_cleanup (void *cls)
const struct GNUNET_TESTING_Command	GNUNET_TESTING_CORE_cmd_send (const char *label, uint64_t num_messages, enum GNUNET_GenericReturnValue await_new_connection)

Macro Definition Documentation

LOG

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

Generic logging shortcut.

Definition at line 37 of file testing_core_cmd_send.c.

Function Documentation

connect_cb()

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

static

Definition at line 135 of file testing_core_cmd_send.c.

{
  struct SendState *send_state = cls;
 
  send_messages (send_state);
  // FIXME this returns something but the calling function discards the
  // returned value anyways
  return NULL;
}

References send_messages().

Referenced by cleanup_callbacks(), and exec_send_run().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_callbacks()

static void cleanup_callbacks ( struct SendState *  send_state )

static

Definition at line 56 of file testing_core_cmd_send.c.

{
  const struct GNUNET_TESTING_CORE_ConnectState *connect_state =
    send_state->connect_state;
  struct GNUNET_TESTING_CORE_ConnectCb *connect_cb_iter;
 
  for (uint64_t i = 0; i < connect_state->connect_cbs_len; i++)
  {
    connect_cb_iter = &connect_state->connect_cbs[i];
    if (connect_cb == connect_cb_iter->callback)
    {
      /* remove the callback */
      GNUNET_memcpy (connect_cb_iter,
                     connect_cb_iter + 1,
                     (connect_state->connect_cbs_len - i - 1) *
                       sizeof (struct GNUNET_TESTING_CORE_ConnectCb));
      GNUNET_array_grow (connect_state->connect_cbs,
                         connect_state->connect_cbs_len,
                         connect_state->connect_cbs_len - 1);
      //FIXME the following seems to be a double free, but I currently don't
      //know where the other free should be
      //GNUNET_free (connect_cb_iter);
    }
  }
}

References GNUNET_TESTING_CORE_ConnectCb::callback, connect_cb(), GNUNET_TESTING_CORE_ConnectState::connect_cbs, GNUNET_TESTING_CORE_ConnectState::connect_cbs_len, SendState::connect_state, GNUNET_array_grow, and GNUNET_memcpy.

Referenced by send_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

send_messages()

static void send_messages ( struct SendState *  send_state )

static

Definition at line 84 of file testing_core_cmd_send.c.

{
  const struct GNUNET_TESTING_CORE_ConnectState *connect_state =
    send_state->connect_state;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTING_CORE_Message *msg;
  struct GNUNET_TESTING_CORE_Channel *channel_iter;
  uint64_t channel_index = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "Going to send %" PRIu64 " messages\n",
      send_state->num_messages);
  GNUNET_assert (NULL != connect_state->channels_head);
  /* For now send on all available channels as we don't know at this stage
   * which is an usable channel - this should be fine as the unusable channel
   * will (probably) be discoverd and cleand up in the process. */
  for (channel_iter = connect_state->channels_head;
       NULL != channel_iter;
       channel_iter = channel_iter->next)
  {
    for (uint64_t i = 0; i < send_state->num_messages; i++)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Going to send message (type %u) %" PRIu64 ", %s (channel %" PRIu64 ") to %s\n",
           MTYPE,
           i,
           connect_state->node_id,
           channel_index,
           GNUNET_i2s (&channel_iter->peer_id));
      env = GNUNET_MQ_msg (msg, MTYPE); // usually we wanted to keep the
                                        // envelopes to potentially cancel the
                                        // message
      msg->id = GNUNET_htonll (i);
      msg->batch = GNUNET_htonll (channel_index);
      GNUNET_memcpy (msg->node_id, connect_state->node_id, NODE_ID_LEN);
      GNUNET_MQ_send (channel_iter->mq, env);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Sent message %" PRIu64 " (channel %" PRIu64 ")\n",
           i,
           channel_index);
    }
    channel_index++;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sent messages\n");
 
  cleanup_callbacks (send_state);
  GNUNET_free (send_state);
}

References GNUNET_TESTING_CORE_ConnectState::channels_head, cleanup_callbacks(), GNUNET_TESTING_CORE_Channel::connect_state, SendState::connect_state, env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_htonll(), GNUNET_i2s(), GNUNET_memcpy, GNUNET_MQ_msg, GNUNET_MQ_send(), LOG, GNUNET_TESTING_CORE_Channel::mq, msg, MTYPE, GNUNET_TESTING_CORE_Channel::next, GNUNET_TESTING_CORE_ConnectState::node_id, NODE_ID_LEN, SendState::num_messages, and GNUNET_TESTING_CORE_Channel::peer_id.

Referenced by connect_cb(), and exec_send_run().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_send_run()

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

static

Definition at line 150 of file testing_core_cmd_send.c.

{
  struct SendState *send_state = cls;
  const struct GNUNET_TESTING_CORE_ConnectState *connect_state;
 
  // TODO make the "connect" label an input to the command
  if (GNUNET_OK != GNUNET_CORE_TESTING_get_trait_connect (
        GNUNET_TESTING_interpreter_lookup_command (is, "connect"),
        &connect_state)) {
    GNUNET_assert (0);
  };
  send_state->connect_state = connect_state;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Going to (register to) send messages\n");
 
  if ((NULL != connect_state->channels_head) &&
      (GNUNET_NO == send_state->await_new_connection))
  {
    /* We are connected to a peer - send messages */
    send_messages (send_state);
  }
  else
  {
    /* We are not connected yet - subscribe via callback */
    // FIXME is the following ok?
    struct GNUNET_TESTING_CORE_ConnectCb *connect_cb_struct =
      GNUNET_new (struct GNUNET_TESTING_CORE_ConnectCb);
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Registering our connect callback with the connect callbacks\n");
    connect_cb_struct->callback = connect_cb;
    connect_cb_struct->cls = send_state;
    GNUNET_array_append (connect_state->connect_cbs,
                         connect_state->connect_cbs_len,
                         *connect_cb_struct);
  }
}

References SendState::await_new_connection, GNUNET_TESTING_CORE_ConnectCb::callback, GNUNET_TESTING_CORE_ConnectState::channels_head, GNUNET_TESTING_CORE_ConnectCb::cls, connect_cb(), GNUNET_TESTING_CORE_ConnectState::connect_cbs, GNUNET_TESTING_CORE_ConnectState::connect_cbs_len, SendState::connect_state, GNUNET_array_append, GNUNET_assert, GNUNET_CORE_TESTING_get_trait_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_TESTING_interpreter_lookup_command(), is, LOG, and send_messages().

Referenced by GNUNET_TESTING_CORE_cmd_send().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_send_cleanup()

static void exec_send_cleanup ( void *  cls )

static

Definition at line 189 of file testing_core_cmd_send.c.

{
  struct GNUNET_TESTING_CORE_ConnectState *connect_state = cls;
 
}

Referenced by GNUNET_TESTING_CORE_cmd_send().

Here is the caller graph for this function:

GNUNET_TESTING_CORE_cmd_send()

const struct GNUNET_TESTING_Command GNUNET_TESTING_CORE_cmd_send	(	const char *	label,
		uint64_t	num_messages,
		enum GNUNET_GenericReturnValue	await_new_connection
	)

Definition at line 198 of file testing_core_cmd_send.c.

{
  struct SendState *send_state;
 
  // TODO make struct static global?
  send_state = GNUNET_new (struct SendState);
  send_state->num_messages = num_messages;
  send_state->await_new_connection = await_new_connection;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "(Setting up _cmd_send)\n");
  return GNUNET_TESTING_command_new (
      send_state, // state
      label,
      &exec_send_run,
      &exec_send_cleanup,
      NULL);
}

References SendState::await_new_connection, exec_send_cleanup(), exec_send_run(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_TESTING_command_new, LOG, and SendState::num_messages.

Here is the call graph for this function: