#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_lib.h"
#include "testing_api_loop.h"
#include "testing_cmds.h"
#include "testing_api_topology.h"

Include dependency graph for gnunet-cmds-helper.c:

Data Structures
struct	WriteContext
	Context for a single write on a chunk of memory. More...

Macros
#define	LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
	Generic logging shortcut. More...

#define	LOG_DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
	Debug logging shorthand. More...

Functions
static void	do_shutdown_later (void *cls)
	Task to shut down cleanly. More...

static void	do_shutdown (void *cls)
	Task to shut down cleanly. More...

static void	write_task (void *cls)
	Task to write to the standard out. More...

static void	write_message (const struct GNUNET_MessageHeader *message)
	Callback to write a message to the parent process. More...

static void	finished_cb (void *cls, enum GNUNET_GenericReturnValue rv)

static enum GNUNET_GenericReturnValue	check_helper_init (void cls, const struct GNUNET_TESTING_CommandHelperInit msg)

static void	handle_helper_init (void cls, const struct GNUNET_TESTING_CommandHelperInit msg)

static void	handle_helper_barrier_crossable (void cls, const struct GNUNET_TESTING_CommandBarrierSatisfied cbs)

static enum GNUNET_GenericReturnValue	tokenizer_cb (void cls, const struct GNUNET_MessageHeader message)
	Functions with this signature are called whenever a complete message is received by the tokenizer. More...

static void	read_task (void *cls)
	Task to read from stdin. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run. More...

int	main (int argc, char **argv)
	Main function. More...

Variables
static struct WriteContext *	wc_head

static struct WriteContext *	wc_tail

static struct GNUNET_TESTING_Interpreter *	is

static const char *	my_node_id

static struct GNUNET_TESTING_PluginFunctions *	plugin
	Plugin to dynamically load a test case. More...

static char *	plugin_name
	Name of our plugin. More...

struct GNUNET_TESTING_NetjailTopology *	njt
	The loaded topology. More...

static struct GNUNET_MessageStreamTokenizer *	tokenizer
	Our message stream tokenizer. More...

static struct GNUNET_DISK_FileHandle *	stdin_fd
	Disk handle from stdin. More...

static struct GNUNET_DISK_FileHandle *	stdout_fd
	Disk handle for stdout. More...

static struct GNUNET_SCHEDULER_Task *	read_task_id
	Task identifier for the read task. More...

static struct GNUNET_SCHEDULER_Task *	write_task_id
	Task identifier for the write task. More...

static int	global_ret
	Result to return in case we fail. More...

static bool	finished
	Set to true once we are finished and should exit after sending our final message to the parent. More...

Macro Definition Documentation

◆ LOG

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

Generic logging shortcut.

Definition at line 47 of file gnunet-cmds-helper.c.

◆ LOG_DEBUG

#define LOG_DEBUG ( ... ) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Debug logging shorthand.

Definition at line 52 of file gnunet-cmds-helper.c.

Function Documentation

◆ do_shutdown_later()

static void do_shutdown_later ( void * cls )

static

Task to shut down cleanly.

Parameters

cls NULL

Definition at line 147 of file gnunet-cmds-helper.c.

{
  struct WriteContext *wc;
 
  if (NULL != read_task_id)
  {
    GNUNET_SCHEDULER_cancel (read_task_id);
    read_task_id = NULL;
  }
  if (NULL != write_task_id)
  {
    GNUNET_SCHEDULER_cancel (write_task_id);
    write_task_id = NULL;
  }
  while (NULL != (wc = wc_head))
  {
    GNUNET_CONTAINER_DLL_remove (wc_head,
                                 wc_tail,
                                 wc);
    GNUNET_free (wc->data);
    GNUNET_free (wc);
  }
  if (NULL != tokenizer)
  {
    GNUNET_MST_destroy (tokenizer);
    tokenizer = NULL;
  }
  if (NULL != plugin)
  {
    GNUNET_PLUGIN_unload (plugin_name,
                          plugin);
    plugin = NULL;
  }
  if (NULL != njt)
  {
    GNUNET_TESTING_free_topology (njt);
    njt = NULL;
  }
}

References WriteContext::data, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MST_destroy(), GNUNET_PLUGIN_unload(), GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_free_topology(), njt, plugin, plugin_name, read_task_id, tokenizer, wc_head, wc_tail, and write_task_id.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Task to shut down cleanly.

Parameters

cls NULL

Definition at line 194 of file gnunet-cmds-helper.c.

{
  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                      &do_shutdown_later,
                                      NULL);
}

References do_shutdown_later(), GNUNET_SCHEDULER_add_with_priority(), and GNUNET_SCHEDULER_PRIORITY_IDLE.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_task()

static void write_task ( void * cls )

static

Task to write to the standard out.

Parameters

cls	the WriteContext

Definition at line 208 of file gnunet-cmds-helper.c.

{
  struct WriteContext *wc = wc_head;
  ssize_t bytes_wrote;
 
  write_task_id = NULL;
  if (NULL == wc)
  {
    if (finished)
      GNUNET_SCHEDULER_shutdown ();
    return;
  }
  bytes_wrote
    = GNUNET_DISK_file_write (stdout_fd,
                              wc->data + wc->pos,
                              wc->length - wc->pos);
  if (GNUNET_SYSERR == bytes_wrote)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                         "write");
    GNUNET_free (wc->data);
    GNUNET_free (wc);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  wc->pos += bytes_wrote;
  if (wc->pos == wc->length)
  {
    GNUNET_CONTAINER_DLL_remove (wc_head,
                                 wc_tail,
                                 wc);
    GNUNET_free (wc->data);
    GNUNET_free (wc);
  }
  write_task_id
    = GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                       stdout_fd,
                                       &write_task,
                                       NULL);
}

References WriteContext::data, finished, global_ret, GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_SCHEDULER_add_write_file(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, WriteContext::length, WriteContext::pos, stdout_fd, wc_head, wc_tail, write_task(), and write_task_id.

Referenced by write_message(), and write_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_message()

static void write_message ( const struct GNUNET_MessageHeader * message )

static

Callback to write a message to the parent process.

Definition at line 256 of file gnunet-cmds-helper.c.

{
  struct WriteContext *wc;
  size_t msg_length = ntohs (message->size);
 
  wc = GNUNET_new (struct WriteContext);
  wc->length = msg_length;
  wc->data = GNUNET_memdup (message,
                            msg_length);
  GNUNET_CONTAINER_DLL_insert_tail (wc_head,
                                    wc_tail,
                                    wc);
  if (NULL == write_task_id)
  {
    GNUNET_assert (wc_head == wc);
    write_task_id
      = GNUNET_SCHEDULER_add_write_file (
          GNUNET_TIME_UNIT_FOREVER_REL,
          stdout_fd,
          &write_task,
          NULL);
  }
}

References WriteContext::data, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_memdup, GNUNET_new, GNUNET_SCHEDULER_add_write_file(), GNUNET_TIME_UNIT_FOREVER_REL, WriteContext::length, GNUNET_MessageHeader::size, stdout_fd, wc_head, wc_tail, write_task(), and write_task_id.

Referenced by finished_cb(), and handle_helper_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finished_cb()

static void finished_cb	(	void *	cls,
		enum GNUNET_GenericReturnValue	rv
	)

static

Definition at line 282 of file gnunet-cmds-helper.c.

{
  struct GNUNET_TESTING_CommandLocalFinished reply = {
    .header.type = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED),
    .header.size = htons (sizeof (reply)),
    .rv = htonl ((uint32_t) rv)
  };
 
  (void) cls;
  finished = true;
  write_message (&reply.header);
}

References finished, GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED, GNUNET_TESTING_CommandLocalFinished::header, GNUNET_TESTING_CommandLocalFinished::rv, GNUNET_MessageHeader::type, and write_message().

Referenced by GDS_u_send(), GNUNET_NAMESTORE_record_set_edit_cancel(), gnunet_send(), handle_helper_init(), and ip_send().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_helper_init()

static enum GNUNET_GenericReturnValue check_helper_init	(	void *	cls,
		const struct GNUNET_TESTING_CommandHelperInit *	msg
	)

static

Definition at line 298 of file gnunet-cmds-helper.c.

{
  uint16_t msize = ntohs (msg->header.size);
  uint32_t barrier_count = ntohl (msg->barrier_count);
  size_t bs = barrier_count * sizeof (struct GNUNET_ShortHashCode);
  size_t left = msize - bs - sizeof (*msg);
  const struct GNUNET_ShortHashCode *bd
    = (const struct GNUNET_ShortHashCode *) &msg[1];
  const char *topo = (const char *) &bd[barrier_count];
 
  if (msize < bs + sizeof (*msg))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ('\0' != topo[left - 1])
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

◆ handle_helper_init()

static void handle_helper_init	(	void *	cls,
		const struct GNUNET_TESTING_CommandHelperInit *	msg
	)

static

Definition at line 325 of file gnunet-cmds-helper.c.

{
  uint16_t msize = ntohs (msg->header.size);
  // uint32_t barrier_count = GNUNET_ntohll (msg->barrier_count);
  uint32_t barrier_count = ntohl (msg->barrier_count);
  size_t bs = barrier_count * sizeof (struct GNUNET_ShortHashCode);
  size_t left = msize - bs - sizeof (*msg);
  const struct GNUNET_ShortHashCode *bd
    = (const struct GNUNET_ShortHashCode *) &msg[1];
  const char *topo = (const char *) &bd[barrier_count];
  const struct GNUNET_OS_ProjectData *pd
    = GNUNET_OS_project_data_gnunet ();
 
  if (NULL != plugin)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Double-init!\n");
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  GNUNET_assert ('\0' == topo[left - 1]);
  njt = GNUNET_TESTING_get_topo_from_string_ (topo);
  if (NULL == njt)
  {
    GNUNET_break_op (0);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  plugin_name = GNUNET_TESTING_get_plugin_from_topo (njt,
                                                     my_node_id);
  plugin = GNUNET_PLUGIN_load (pd,
                               plugin_name,
                               (void *) my_node_id);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting plugin `%s' for node %s\n",
              plugin_name,
              my_node_id);
  if (NULL == plugin)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Plugin `%s' not found!\n",
                plugin_name);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  {
    struct GNUNET_TESTING_Command *commands = plugin->cls;
 
    for (unsigned int i = 0; NULL != commands[i].run; i++)
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "helper %s\n",
                  commands[i].label.value);
  }
  is = plugin->start_testcase (plugin->cls,
                               topo,
                               barrier_count,
                               bd,
                               &write_message,
                               &finished_cb,
                               NULL);
}

References GNUNET_TESTING_PluginFunctions::cls, commands, finished_cb(), global_ret, GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OS_project_data_gnunet(), GNUNET_PLUGIN_load(), GNUNET_SCHEDULER_shutdown(), GNUNET_TESTING_get_plugin_from_topo(), GNUNET_TESTING_get_topo_from_string_(), is, GNUNET_TESTING_Command::label, msg, my_node_id, njt, plugin, plugin_name, GNUNET_MessageHeader::size, GNUNET_TESTING_PluginFunctions::start_testcase, GNUNET_TESTING_CommandLabel::value, and write_message().

Here is the call graph for this function:

◆ handle_helper_barrier_crossable()

static void handle_helper_barrier_crossable	(	void *	cls,
		const struct GNUNET_TESTING_CommandBarrierSatisfied *	cbs
	)

static

Definition at line 395 of file gnunet-cmds-helper.c.

{
  struct GNUNET_TESTING_Barrier *barrier;
 
  if (NULL == is)
  {
    /* Barrier satisfied *before* helper_init?! */
    GNUNET_break_op (0);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  barrier = GNUNET_TESTING_get_barrier2_ (is,
                                          &cbs->barrier_key);
  if (barrier->satisfied)
  {
    /* Barrier satisfied *twice* is strange... */
    GNUNET_break_op (0);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  barrier->satisfied = true;
  GNUNET_TESTING_loop_notify_children_ (is,
                                        &cbs->header);
  for (unsigned int i = 0; i<barrier->cnt_waiting; i++)
    GNUNET_TESTING_async_finish (barrier->waiting[i]);
  GNUNET_array_grow (barrier->waiting,
                     barrier->cnt_waiting,
                     0);
}

References GNUNET_TESTING_CommandBarrierSatisfied::barrier_key, GNUNET_TESTING_Barrier::cnt_waiting, global_ret, GNUNET_array_grow, GNUNET_break_op, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTING_async_finish(), GNUNET_TESTING_get_barrier2_(), GNUNET_TESTING_loop_notify_children_(), GNUNET_TESTING_CommandBarrierSatisfied::header, is, GNUNET_TESTING_Barrier::satisfied, and GNUNET_TESTING_Barrier::waiting.

Here is the call graph for this function:

◆ tokenizer_cb()

static enum GNUNET_GenericReturnValue tokenizer_cb	(	void *	cls,
		const struct GNUNET_MessageHeader *	message
	)

static

Functions with this signature are called whenever a complete message is received by the tokenizer.

Do not call #GNUNET_mst_destroy() in this callback

Parameters

cls	identification of the client
message	the actual message

Returns: GNUNET_OK on success, GNUNET_NO to stop further processing (no error) GNUNET_SYSERR to stop further processing with error

Definition at line 443 of file gnunet-cmds-helper.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (
      helper_init,
      GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT,
      struct GNUNET_TESTING_CommandHelperInit,
      NULL),
    GNUNET_MQ_hd_fixed_size (
      helper_barrier_crossable,
      GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE,
      struct GNUNET_TESTING_CommandBarrierSatisfied,
      NULL),
    GNUNET_MQ_handler_end ()
  };
 
  return GNUNET_MQ_handle_message (handlers,
                                   message);
}

References GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE, GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT, GNUNET_MQ_handle_message(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, and handlers.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_task()

static void read_task ( void * cls )

static

Task to read from stdin.

Parameters

cls NULL

Definition at line 471 of file gnunet-cmds-helper.c.

{
  char buf[GNUNET_MAX_MESSAGE_SIZE];
  ssize_t sread;
 
  read_task_id = NULL;
  sread = GNUNET_DISK_file_read (stdin_fd,
                                 buf,
                                 sizeof(buf));
  if (GNUNET_SYSERR == sread)
  {
    GNUNET_break (0);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (0 == sread)
  {
    LOG_DEBUG ("STDIN eof\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK !=
      GNUNET_MST_from_buffer (tokenizer,
                              buf,
                              sread,
                              GNUNET_NO,
                              GNUNET_NO))
  {
    GNUNET_break (0);
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  read_task_id
    = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                      stdin_fd,
                                      &read_task,
                                      NULL);
}

References global_ret, GNUNET_break, GNUNET_DISK_file_read(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, LOG_DEBUG, read_task(), read_task_id, stdin_fd, and tokenizer.

Referenced by read_task(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 522 of file gnunet-cmds-helper.c.

{
  if (NULL == args[0])
  {
    /* must be called with our node ID as 1st argument */
    GNUNET_break_op (0);
    global_ret = EXIT_INVALIDARGUMENT;
    return;
  }
  my_node_id = args[0];
  tokenizer = GNUNET_MST_create (&tokenizer_cb,
                                 NULL);
  stdin_fd = GNUNET_DISK_get_handle_from_native (stdin);
  stdout_fd = GNUNET_DISK_get_handle_from_native (stdout);
  read_task_id = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 stdin_fd,
                                                 &read_task,
                                                 NULL);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
}

References consensus-simulation::args, do_shutdown(), EXIT_INVALIDARGUMENT, global_ret, GNUNET_break_op, GNUNET_DISK_get_handle_from_native(), GNUNET_MST_create(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_TIME_UNIT_FOREVER_REL, my_node_id, read_task(), read_task_id, stdin_fd, stdout_fd, tokenizer, and tokenizer_cb().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char **	argv
	)

Main function.

Parameters

argc	the number of command line arguments
argv	command line arg array

Returns: return code

Definition at line 556 of file gnunet-cmds-helper.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  enum GNUNET_GenericReturnValue ret;
  const struct GNUNET_OS_ProjectData *pd
    = GNUNET_OS_project_data_gnunet ();
 
  ret = GNUNET_PROGRAM_run (pd,
                            argc,
                            argv,
                            "gnunet-cmds-helper",
                            "Helper for starting a local interpreter loop",
                            options,
                            &run,
                            NULL);
  if (GNUNET_OK != ret)
    return 1;
  return global_ret;
}