arm for writing a tool More...

#include "platform.h"
#include "gnunet_arm_service.h"
#include "gnunet_util_lib.h"

Include dependency graph for gnunet-arm.c:

Functions
static void	delete_files ()
	Attempts to delete configuration file and GNUNET_HOME on ARM shutdown provided the end and delete options were specified when gnunet-arm was run.

static void	shutdown_task (void *cls)
	Main continuation-passing-style loop.

static const char *	req_string (enum GNUNET_ARM_RequestStatus rs)
	Returns a string interpretation of rs.

static const char *	ret_string (enum GNUNET_ARM_Result result)
	Returns a string interpretation of the result.

static bool	arm_is_running (void)
	Check if the ARM service is (likely) running.

static void	action_loop (void *cls)
	Main task that runs our various operations in order.

static void	conn_status (void *cls, int connected)
	Function called whenever we connect to or disconnect from ARM.

static void	start_callback (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
	We have requested ARM to be started, this function is called with the result of the operation.

static void	stop_callback (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
	We have requested ARM to be stopped, this function is called with the result of the operation.

static void	init_callback (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
	We have requested a service to be started, this function is called with the result of the operation.

static void	term_callback (void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
	We have requested a service to be stopped, this function is called with the result of the operation.

static void	list_callback (void cls, enum GNUNET_ARM_RequestStatus rs, unsigned int count, const struct GNUNET_ARM_ServiceInfo service_info)
	Function called with the list of running services.

static void	srv_status (void cls, const char service, enum GNUNET_ARM_ServiceMonitorStatus status)
	Function called when a service starts or stops.

static void	timeout_task_cb (void *cls)
	Task run on timeout (if -T is given).

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run by the scheduler.

int	main (int argc, char const argv)
	The main function to obtain arm from gnunetd.

Variables
static int	end
	Set if we are to shutdown all services (including ARM).

static int	start
	Set if we are to start default services (including ARM).

static int	restart
	Set if we are to stop/start default services (including ARM).

static int	delete
	Set if we should delete configuration and temp directory on exit.

static int	quiet
	Set if we should not print status messages.

static int	show_all
	Set if we should print all services, including stopped ones.

static int	monitor
	Monitor ARM activity.

static int	list
	Set if we should print a list of currently running services.

static char *	init
	Set to the name of a service to start.

static char *	term
	Set to the name of a service to kill.

static char *	config_file
	Set to the name of the config file used.

static char *	dir
	Set to the directory where runtime files are stored.

static int	ret
	Final status code.

static struct GNUNET_ARM_Handle *	h
	Connection with ARM.

static struct GNUNET_ARM_MonitorHandle *	m
	Monitor connection with ARM.

static struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration.

static unsigned int	phase
	Processing stage that we are in.

static struct GNUNET_TIME_Relative	timeout
	User defined timestamp for completing operations.

static struct GNUNET_SCHEDULER_Task *	timeout_task
	Task to be run on timeout.

static int	no_stdout
	Do we want to give our stdout to gnunet-service-arm?

static int	no_stderr
	Do we want to give our stderr to gnunet-service-arm?

static struct GNUNET_SCHEDULER_Task *	al_task
	Handle for the task running the action_loop().

static struct GNUNET_ARM_Operation *	op
	Current operation.

Detailed Description

arm for writing a tool

Author: Christian Grothoff

Definition in file gnunet-arm.c.

Function Documentation

◆ delete_files()

static void delete_files ( )

static

Attempts to delete configuration file and GNUNET_HOME on ARM shutdown provided the end and delete options were specified when gnunet-arm was run.

Definition at line 151 of file gnunet-arm.c.

{
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Will attempt to remove configuration file %s and service directory %s\n",
    config_file,
    dir);
  if (0 != unlink (config_file))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to remove configuration file %s\n"),
                config_file);
  }
  if (GNUNET_OK != GNUNET_DISK_directory_remove (dir))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to remove servicehome directory %s\n"),
                dir);
  }
}

References _, config_file, dir, GNUNET_DISK_directory_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and GNUNET_OK.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void * cls )

static

Main continuation-passing-style loop.

Runs the various jobs that we've been asked to do in order.

Parameters

cls	closure, unused

Definition at line 180 of file gnunet-arm.c.

{
  (void) cls;
  if (NULL != al_task)
  {
    GNUNET_SCHEDULER_cancel (al_task);
    al_task = NULL;
  }
  if (NULL != op)
  {
    GNUNET_ARM_operation_cancel (op);
    op = NULL;
  }
  if (NULL != h)
  {
    GNUNET_ARM_disconnect (h);
    h = NULL;
  }
  if (NULL != m)
  {
    GNUNET_ARM_monitor_stop (m);
    m = NULL;
  }
  if (NULL != timeout_task)
  {
    GNUNET_SCHEDULER_cancel (timeout_task);
    timeout_task = NULL;
  }
  if ( (GNUNET_YES == end) &&
       (GNUNET_YES == delete) )
    delete_files ();
  GNUNET_CONFIGURATION_destroy (cfg);
  cfg = NULL;
}

References al_task, cfg, delete_files(), end, GNUNET_ARM_disconnect(), GNUNET_ARM_monitor_stop(), GNUNET_ARM_operation_cancel(), GNUNET_CONFIGURATION_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, h, m, op, and timeout_task.

Here is the call graph for this function:

◆ req_string()

static const char * 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 223 of file gnunet-arm.c.

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

References _, GNUNET_ARM_REQUEST_DISCONNECTED, and GNUNET_ARM_REQUEST_SENT_OK.

Referenced by init_callback(), list_callback(), start_callback(), stop_callback(), and term_callback().

Here is the caller graph for this function:

◆ ret_string()

static const char * 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 244 of file gnunet-arm.c.

{
  switch (result)
  {
  case GNUNET_ARM_RESULT_STOPPED:
    return _ ("is stopped");
 
  case GNUNET_ARM_RESULT_STARTING:
    return _ ("is starting");
 
  case GNUNET_ARM_RESULT_STOPPING:
    return _ ("is stopping");
 
  case GNUNET_ARM_RESULT_IS_STARTING_ALREADY:
    return _ ("is starting already");
 
  case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY:
    return _ ("is stopping already");
 
  case GNUNET_ARM_RESULT_IS_STARTED_ALREADY:
    return _ ("is started already");
 
  case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY:
    return _ ("is stopped already");
 
  case GNUNET_ARM_RESULT_IS_NOT_KNOWN:
    return _ ("service is not known to ARM");
 
  case GNUNET_ARM_RESULT_START_FAILED:
    return _ ("service failed to start");
 
  case GNUNET_ARM_RESULT_IN_SHUTDOWN:
    return _ ("service cannot be manipulated because ARM is shutting down");
  }
  return _ ("Unknown result code.");
}

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, GNUNET_ARM_RESULT_STOPPING, and result.

Referenced by init_callback(), start_callback(), stop_callback(), and term_callback().

Here is the caller graph for this function:

◆ arm_is_running()

static bool arm_is_running ( void )

static

Check if the ARM service is (likely) running.

Note that we cannot simply try to connect and wait for the connection to fail: the client API keeps retrying forever, so an action that requires ARM would simply block until the user hits CTRL-C.

Returns: true if the ARM service seems to be up

Definition at line 291 of file gnunet-arm.c.

{
  return (GNUNET_YES ==
          GNUNET_CLIENT_test (cfg,
                              "arm"));
}

References cfg, GNUNET_CLIENT_test(), and GNUNET_YES.

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ action_loop()

static void action_loop ( void * cls )

static

Main task that runs our various operations in order.

Main action loop.

Parameters

cls closure

Runs the various jobs that we've been asked to do, in order.

Parameters

cls	closure, unused

Definition at line 746 of file gnunet-arm.c.

{
  (void) cls;
  al_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Running requested actions\n");
  while (1)
  {
    switch (phase++)
    {
    case 0:
      if (NULL != term)
      {
        if (! arm_is_running ())
        {
          fprintf (stderr,
                   _ ("Cannot stop the `%s' service: ARM is not running.\n"),
                   term);
          ret = 4;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Termination action\n");
        op = GNUNET_ARM_request_service_stop (h,
                                              term,
                                              &term_callback,
                                              NULL);
        return;
      }
      break;
 
    case 1:
      if (end || restart)
      {
        if (! arm_is_running ())
        {
          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                      "GNUnet not running, cannot stop the peer\n");
          if (restart)
          {
            /* nothing to stop, so just start the peer */
            restart = 0;
            start = 1;
          }
        }
        else
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "End action\n");
          op = GNUNET_ARM_request_service_stop (h,
                                                "arm",
                                                &stop_callback,
                                                NULL);
          return;
        }
      }
      break;
 
    case 2:
      if (start)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Start action\n");
        op =
          GNUNET_ARM_request_service_start (h,
                                            "arm",
                                            (no_stdout
                                             ? 0
                                             : GNUNET_OS_INHERIT_STD_OUT)
                                            | (no_stderr
                                               ? 0
                                               : GNUNET_OS_INHERIT_STD_ERR),
                                            &start_callback,
                                            NULL);
        return;
      }
      break;
 
    case 3:
      if (NULL != init)
      {
        if (! arm_is_running ())
        {
          fprintf (stderr,
                   _ ("Cannot start the `%s' service: ARM is not running.\n"),
                   init);
          ret = 4;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Initialization action\n");
        op = GNUNET_ARM_request_service_start (h,
                                               init,
                                               GNUNET_OS_INHERIT_STD_NONE,
                                               &init_callback,
                                               NULL);
        return;
      }
      break;
 
    case 4:
      if (list)
      {
        if (! arm_is_running ())
        {
          fprintf (stderr,
                   "%s",
                   _ ("Cannot list services: ARM is not running.\n"));
          ret = 4;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Going to list all running services controlled by ARM.\n");
        op = GNUNET_ARM_request_service_list (h,
                                              &list_callback,
                                              &list);
        return;
      }
      break;
 
    case 5:
      if (monitor)
      {
        if (! quiet)
          fprintf (stderr,
                   _ ("Now only monitoring, press CTRL-C to stop.\n"));
        quiet =
          0;       /* does not make sense to stay quiet in monitor mode at this time */
        return;       /* done with tasks, just monitor */
      }
      break;
 
    default:     /* last phase */
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
  }
}

References _, al_task, arm_is_running(), end, GNUNET_ARM_request_service_list(), GNUNET_ARM_request_service_start(), GNUNET_ARM_request_service_stop(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OS_INHERIT_STD_ERR, GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_INHERIT_STD_OUT, GNUNET_SCHEDULER_shutdown(), h, init, init_callback(), list, list_callback(), monitor, no_stderr, no_stdout, op, phase, quiet, restart, ret, start, start_callback(), stop_callback(), term, and term_callback().

Referenced by init_callback(), list_callback(), run(), start_callback(), stop_callback(), and term_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ conn_status()

static void conn_status	(	void *	cls,
		int	connected
	)

static

Function called whenever we connect to or disconnect from ARM.

Terminates the process if we fail to connect to the service on our first attempt.

Parameters

cls	closure
connected	GNUNET_YES if connected, GNUNET_NO if disconnected, GNUNET_SYSERR on error.

Definition at line 318 of file gnunet-arm.c.

{
  static int once;
 
  (void) cls;
  if ( (GNUNET_SYSERR == connected) &&
       (0 == once) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Fatal error initializing ARM API.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  once = 1;
}

References _, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, and once.

Referenced by GNUNET_ARM_connect(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ start_callback()

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

static

We have requested ARM to be started, this function is called with the result of the operation.

Informs the use of the result; on success, we continue with the event loop, on failure we terminate the process.

Parameters

cls	closure unused
rs	what happened to our request
result	if the request was processed, this is the result according to ARM

Definition at line 348 of file gnunet-arm.c.

{
  (void) cls;
  op = NULL;
  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
  {
    fprintf (stdout,
             _ ("Failed to start the ARM service: %s\n"),
             req_string (rs));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if ((GNUNET_ARM_RESULT_STARTING != result) &&
      (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result))
  {
    fprintf (stdout,
             _ ("Failed to start the ARM service: %s\n"),
             ret_string (result));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "ARM service [re]start successful\n");
  start = 0;
  al_task = GNUNET_SCHEDULER_add_now (&action_loop,
                                      NULL);
}

References _, action_loop(), al_task, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_STARTED_ALREADY, GNUNET_ARM_RESULT_STARTING, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), op, req_string(), result, ret_string(), and start.

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stop_callback()

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

static

We have requested ARM to be stopped, this function is called with the result of the operation.

Informs the use of the result; on success, we continue with the event loop, on failure we terminate the process.

Parameters

cls	closure unused
rs	what happened to our request
result	if the request was processed, this is the result according to ARM

Definition at line 391 of file gnunet-arm.c.

{
  char *msg;
 
  (void) cls;
  op = NULL;
  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
  {
    GNUNET_asprintf (&msg,
                     "%s",
                     _ (
                       "Failed to send a stop request to the ARM service: %s\n")
                     );
    fprintf (stdout, msg, req_string (rs));
    GNUNET_free (msg);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if ( (GNUNET_ARM_RESULT_STOPPING != result) &&
       (GNUNET_ARM_RESULT_STOPPED != result) &&
       (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result) )
  {
    fprintf (stdout,
             _ ("Failed to stop the ARM service: %s\n"),
             ret_string (result));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "ARM service shutdown successful\n");
  end = 0;
  if (restart)
  {
    restart = 0;
    start = 1;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Initiating an ARM restart\n");
  }
  al_task = GNUNET_SCHEDULER_add_now (&action_loop,
                                      NULL);
}

References _, action_loop(), al_task, end, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_STOPPED_ALREADY, GNUNET_ARM_RESULT_STOPPED, GNUNET_ARM_RESULT_STOPPING, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), msg, op, req_string(), restart, result, ret_string(), and start.

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_callback()

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

static

We have requested a service to be started, this function is called with the result of the operation.

Informs the use of the result; on success, we continue with the event loop, on failure we terminate the process.

Parameters

cls	closure unused
rs	what happened to our request
result	if the request was processed, this is the result according to ARM

Definition at line 448 of file gnunet-arm.c.

{
  (void) cls;
  op = NULL;
  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
  {
    fprintf (stdout,
             _ ("Failed to send a request to start the `%s' service: %s\n"),
             init,
             req_string (rs));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if ((GNUNET_ARM_RESULT_STARTING != result) &&
      (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result))
  {
    fprintf (stdout,
             _ ("Failed to start the `%s' service: %s\n"),
             init,
             ret_string (result));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Service %s [re]started successfully\n",
              init);
  GNUNET_free (init);
  init = NULL;
  al_task = GNUNET_SCHEDULER_add_now (&action_loop,
                                      NULL);
}

References _, action_loop(), al_task, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_STARTED_ALREADY, GNUNET_ARM_RESULT_STARTING, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), init, op, req_string(), result, and ret_string().

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ term_callback()

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

static

We have requested a service to be stopped, this function is called with the result of the operation.

Informs the use of the result; on success, we continue with the event loop, on failure we terminate the process.

Parameters

cls	closure unused
rs	what happened to our request
result	if the request was processed, this is the result according to ARM

Definition at line 495 of file gnunet-arm.c.

{
  char *msg;
 
  (void) cls;
  op = NULL;
  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
  {
    GNUNET_asprintf (&msg,
                     _ (
                       "Failed to send a request to kill the `%s' service: %%s\n"),
                     term);
    fprintf (stdout,
             msg,
             req_string (rs));
    GNUNET_free (msg);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if ( (GNUNET_ARM_RESULT_STOPPED != result) &&
       (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result) )
  {
    fprintf (stdout,
             _ ("Failed to kill the `%s' service: %s\n"),
             term,
             ret_string (result));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Service %s stopped successfully\n",
              term);
  GNUNET_free (term);
  term = NULL;
  al_task = GNUNET_SCHEDULER_add_now (&action_loop,
                                      NULL);
}

References _, action_loop(), al_task, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_STOPPED_ALREADY, GNUNET_ARM_RESULT_STOPPED, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), msg, op, req_string(), result, ret_string(), and term.

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ list_callback()

static void list_callback	(	void *	cls,
		enum GNUNET_ARM_RequestStatus	rs,
		unsigned int	count,
		const struct GNUNET_ARM_ServiceInfo *	service_info
	)

static

Function called with the list of running services.

Prints the list to stdout, then starts the event loop again. Prints an error message and terminates the process on errors.

Parameters

cls	closure (unused)
rs	request status (success, failure, etc.)
count	number of services in the list
list	list of services managed by arm

Definition at line 548 of file gnunet-arm.c.

{
  unsigned int num_stopped = 0;
  unsigned int num_started = 0;
  unsigned int num_stopping = 0;
  unsigned int num_failed = 0;
  unsigned int num_finished = 0;
  (void) cls;
  op = NULL;
  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
  {
    char *msg;
 
    GNUNET_asprintf (&msg,
                     "%s",
                     _ ("Failed to request a list of services: %s\n"));
    fprintf (stdout,
             msg,
             req_string (rs));
    GNUNET_free (msg);
    ret = 3;
    GNUNET_SCHEDULER_shutdown ();
  }
  if (NULL == service_info)
  {
    fprintf (stderr,
             "%s",
             _ ("Error communicating with ARM. ARM not running?\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret = 3;
    return;
  }
  for (unsigned int i = 0; i < count; i++)
  {
    switch (service_info[i].status)
    {
    case GNUNET_ARM_SERVICE_STATUS_STOPPED:
      num_stopped++;
      break;
    case GNUNET_ARM_SERVICE_STATUS_FAILED:
      num_failed++;
      break;
    case GNUNET_ARM_SERVICE_STATUS_FINISHED:
      num_finished++;
      break;
    case GNUNET_ARM_SERVICE_STATUS_STARTED:
      num_started++;
      break;
    case GNUNET_ARM_SERVICE_STATUS_STOPPING:
      num_stopping++;
      fprintf (stdout,
               "%s (binary='%s', status=stopping)\n",
               service_info[i].name,
               service_info[i].binary);
      break;
    default:
      GNUNET_break_op (0);
      fprintf (stdout,
               "%s (binary='%s', status=unknown)\n",
               service_info[i].name,
               service_info[i].binary);
      break;
    }
  }
  if (! quiet)
  {
    if (show_all)
      fprintf (stdout,
               "%s",
               _ ("All services:\n"));
    else
      fprintf (stdout,
               "%s",
               _ ("Services (excluding stopped services):\n"));
    if (num_stopped || num_failed || num_finished || num_stopping ||
        num_started)
    {
      int sep = 0;
      fprintf (stdout, "(");
      if (0 != num_started)
      {
        if (sep)
          fprintf (stdout, " / ");
        fprintf (stdout,
                 "started: %u",
                 num_started);
        sep = 1;
      }
      if (0 != num_failed)
      {
        if (sep)
          fprintf (stdout, " / ");
        fprintf (stdout,
                 "failed: %u",
                 num_failed);
        sep = 1;
      }
      if (0 != num_stopping)
      {
        if (sep)
          fprintf (stdout, " / ");
        fprintf (stdout,
                 "stopping: %u",
                 num_stopping);
        sep = 1;
      }
      if (0 != num_stopped)
      {
        if (sep)
          fprintf (stdout, " / ");
        fprintf (stdout,
                 "stopped: %u",
                 num_stopped);
        sep = 1;
      }
      if (0 != num_finished)
      {
        if (sep)
          fprintf (stdout, " / ");
        fprintf (stdout,
                 "finished: %u",
                 num_finished);
        sep = 1;
      }
      fprintf (stdout, ")\n");
    }
    else
    {
      fprintf (stdout,
               "%s",
               _ ("(No services configured.)\n"));
    }
  }
  for (unsigned int i = 0; i < count; i++)
  {
    struct GNUNET_TIME_Relative restart_in;
    switch (service_info[i].status)
    {
    case GNUNET_ARM_SERVICE_STATUS_STOPPED:
      if (show_all)
        fprintf (stdout,
                 "%s (binary='%s', status=stopped)\n",
                 service_info[i].name,
                 service_info[i].binary);
      break;
    case GNUNET_ARM_SERVICE_STATUS_FAILED:
      restart_in = GNUNET_TIME_absolute_get_remaining (service_info[i].
                                                       restart_at);
      fprintf (stdout,
               "%s (binary='%s', status=failed, exit_status=%d, restart_delay='%s')\n",
               service_info[i].name,
               service_info[i].binary,
               service_info[i].last_exit_status,
               GNUNET_STRINGS_relative_time_to_string (restart_in,
                                                       GNUNET_YES));
      break;
    case GNUNET_ARM_SERVICE_STATUS_FINISHED:
      fprintf (stdout,
               "%s (binary='%s', status=finished)\n",
               service_info[i].name,
               service_info[i].binary);
      break;
    case GNUNET_ARM_SERVICE_STATUS_STARTED:
      fprintf (stdout,
               "%s (binary='%s', status=started)\n",
               service_info[i].name,
               service_info[i].binary);
      break;
    case GNUNET_ARM_SERVICE_STATUS_STOPPING:
      fprintf (stdout,
               "%s (binary='%s', status=stopping)\n",
               service_info[i].name,
               service_info[i].binary);
      break;
    default:
      GNUNET_break_op (0);
      fprintf (stdout,
               "%s (binary='%s', status=unknown)\n",
               service_info[i].name,
               service_info[i].binary);
      break;
    }
  }
  al_task = GNUNET_SCHEDULER_add_now (&action_loop,
                                      NULL);
}

References _, action_loop(), al_task, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_SERVICE_STATUS_FAILED, GNUNET_ARM_SERVICE_STATUS_FINISHED, GNUNET_ARM_SERVICE_STATUS_STARTED, GNUNET_ARM_SERVICE_STATUS_STOPPED, GNUNET_ARM_SERVICE_STATUS_STOPPING, GNUNET_asprintf(), GNUNET_break_op, GNUNET_free, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, msg, name, op, quiet, req_string(), ret, show_all, and status.

Referenced by action_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ srv_status()

static void srv_status	(	void *	cls,
		const char *	service,
		enum GNUNET_ARM_ServiceMonitorStatus	status
	)

static

Function called when a service starts or stops.

Parameters

cls	closure
service	service name
status	status of the service

Definition at line 897 of file gnunet-arm.c.

{
  const char *msg;
 
  (void) cls;
  switch (status)
  {
  case GNUNET_ARM_SERVICE_MONITORING_STARTED:
    return;   /* this should be done silently */
 
  case GNUNET_ARM_SERVICE_STOPPED:
    msg = _ ("Stopped %s.\n");
    break;
 
  case GNUNET_ARM_SERVICE_STARTING:
    msg = _ ("Starting %s...\n");
    break;
 
  case GNUNET_ARM_SERVICE_STOPPING:
    msg = _ ("Stopping %s...\n");
    break;
 
  default:
    msg = NULL;
    break;
  }
  if (! quiet)
  {
    if (NULL != msg)
      fprintf (stderr,
               msg,
               service);
    else
      fprintf (stderr,
               _ ("Unknown status %u for service %s.\n"),
               status,
               service);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got service %s status %d\n",
              service,
              (int) status);
}

References _, GNUNET_ARM_SERVICE_MONITORING_STARTED, GNUNET_ARM_SERVICE_STARTING, GNUNET_ARM_SERVICE_STOPPED, GNUNET_ARM_SERVICE_STOPPING, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, msg, quiet, service, and status.

Referenced by run().

Here is the caller graph for this function:

◆ timeout_task_cb()

static void timeout_task_cb ( void * cls )

static

Task run on timeout (if -T is given).

Definition at line 948 of file gnunet-arm.c.

{
  (void) cls;
  timeout_task = NULL;
  ret = 2;
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_shutdown(), ret, and timeout_task.

Referenced by 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 *	c
	)

static

Main function that will be run by the scheduler.

Parameters

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

Definition at line 966 of file gnunet-arm.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
  cfg = GNUNET_CONFIGURATION_dup (c);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "PATHS",
                                             "GNUNET_HOME",
                                             &dir))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "PATHS",
                               "GNUNET_HOME");
    return;
  }
  (void) GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                  "arm",
                                                  "CONFIG",
                                                  &config_file);
  if (NULL == (h = GNUNET_ARM_connect (cfg,
                                       &conn_status,
                                       NULL)))
    return;
  if (monitor)
    m = GNUNET_ARM_monitor_start (cfg,
                                  &srv_status,
                                  NULL);
  al_task = GNUNET_SCHEDULER_add_now (&action_loop,
                                      NULL);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  if (0 != timeout.rel_value_us)
    timeout_task =
      GNUNET_SCHEDULER_add_delayed (timeout,
                                    &timeout_task_cb,
                                    NULL);
}

References action_loop(), al_task, cfg, config_file, conn_status(), dir, GNUNET_ARM_connect(), GNUNET_ARM_monitor_start(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), h, m, monitor, GNUNET_TIME_Relative::rel_value_us, shutdown_task, srv_status(), timeout, timeout_task, and timeout_task_cb().

Referenced by finish_test(), GNUNET_TESTING_command_new_ac(), GNUNET_TESTING_interpreter_lookup_command(), main(), and rewind_ip_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char const	argv
	)

The main function to obtain arm from gnunetd.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns: 0 ok, 1 on error, 2 on timeout, 3 on communication failure with ARM, 4 if ARM is not running

Definition at line 1019 of file gnunet-arm.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag ('e',
                               "end",
                               gettext_noop ("stop all GNUnet services"),
                               &end),
    GNUNET_GETOPT_option_string ('i',
                                 "init",
                                 "SERVICE",
                                 gettext_noop ("start a particular service"),
                                 &init),
    GNUNET_GETOPT_option_string ('k',
                                 "kill",
                                 "SERVICE",
                                 gettext_noop ("stop a particular service"),
                                 &term),
    GNUNET_GETOPT_option_flag ('a',
                               "all",
                               gettext_noop (
                                 "also show stopped services (used with -I)"),
                               &show_all),
    GNUNET_GETOPT_option_flag ('s',
                               "start",
                               gettext_noop (
                                 "start all GNUnet default services"),
                               &start),
    GNUNET_GETOPT_option_flag ('r',
                               "restart",
                               gettext_noop (
                                 "stop and start all GNUnet default services"),
                               &restart),
    GNUNET_GETOPT_option_flag ('d',
                               "delete",
                               gettext_noop (
                                 "delete config file and directory on exit"),
                               &delete),
    GNUNET_GETOPT_option_flag ('m',
                               "monitor",
                               gettext_noop ("monitor ARM activities"),
                               &monitor),
    GNUNET_GETOPT_option_flag ('q',
                               "quiet",
                               gettext_noop ("don't print status messages"),
                               &quiet),
    GNUNET_GETOPT_option_relative_time (
      'T',
      "timeout",
      "DELAY",
      gettext_noop (
        "exit with error status if operation does not finish after DELAY"),
      &timeout),
    GNUNET_GETOPT_option_flag ('I',
                               "info",
                               gettext_noop (
                                 "list currently running services"),
                               &list),
    GNUNET_GETOPT_option_flag (
      'O',
      "no-stdout",
      gettext_noop ("don't let gnunet-service-arm inherit standard output"),
      &no_stdout),
    GNUNET_GETOPT_option_flag (
      'E',
      "no-stderr",
      gettext_noop ("don't let gnunet-service-arm inherit standard error"),
      &no_stderr),
    GNUNET_GETOPT_OPTION_END
  };
  int lret;
 
  if (GNUNET_OK ==
      (lret = GNUNET_PROGRAM_run (
         GNUNET_OS_project_data_gnunet (),
         argc,
         argv,
         "gnunet-arm",
         gettext_noop (
           "Control services and the Automated Restart Manager (ARM)"),
         options,
         &run,
         NULL)))
  {
    return ret;
  }
  return lret;
}