gnunet-arm.c File Reference

arm for writing a tool More...

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

Include dependency graph for gnunet-arm.c:

Go to the source code of this file.

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. More...
static void	shutdown_task (void *cls)
	Main continuation-passing-style loop. More...
static const char *	req_string (enum GNUNET_ARM_RequestStatus rs)
	Returns a string interpretation of rs. More...
static const char *	ret_string (enum GNUNET_ARM_Result result)
	Returns a string interpretation of the result. More...
static void	action_loop (void *cls)
	Main task that runs our various operations in order. More...
static void	conn_status (void *cls, int connected)
	Function called whenever we connect to or disconnect from ARM. More...
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. More...
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. More...
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. More...
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. More...
static void	list_callback (void *cls, enum GNUNET_ARM_RequestStatus rs, unsigned int count, const struct GNUNET_ARM_ServiceInfo *list)
	Function called with the list of running services. More...
static void	srv_status (void *cls, const char *service, enum GNUNET_ARM_ServiceMonitorStatus status)
	Function called when a service starts or stops. More...
static void	timeout_task_cb (void *cls)
	Task run on timeout (if -T is given). More...
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. More...
int	main (int argc, char *const *argv)
	The main function to obtain arm from gnunetd. More...

Variables
static int	end
	Set if we are to shutdown all services (including ARM). More...
static int	start
	Set if we are to start default services (including ARM). More...
static int	restart
	Set if we are to stop/start default services (including ARM). More...
static int	delete
	Set if we should delete configuration and temp directory on exit. More...
static int	quiet
	Set if we should not print status messages. More...
static int	show_all
	Set if we should print all services, including stopped ones. More...
static int	monitor
	Monitor ARM activity. More...
static int	list
	Set if we should print a list of currently running services. More...
static char *	init
	Set to the name of a service to start. More...
static char *	term
	Set to the name of a service to kill. More...
static char *	config_file
	Set to the name of the config file used. More...
static char *	dir
	Set to the directory where runtime files are stored. More...
static int	ret
	Final status code. More...
static struct GNUNET_ARM_Handle *	h
	Connection with ARM. More...
static struct GNUNET_ARM_MonitorHandle *	m
	Monitor connection with ARM. More...
static struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration. More...
static unsigned int	phase
	Processing stage that we are in. More...
static struct GNUNET_TIME_Relative	timeout
	User defined timestamp for completing operations. More...
static struct GNUNET_SCHEDULER_Task *	timeout_task
	Task to be run on timeout. More...
static int	no_stdout
	Do we want to give our stdout to gnunet-service-arm? More...
static int	no_stderr
	Do we want to give our stderr to gnunet-service-arm? More...
static struct GNUNET_SCHEDULER_Task *	al_task
	Handle for the task running the action_loop(). More...
static struct GNUNET_ARM_Operation *	op
	Current operation. More...

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 152 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 181 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.

Referenced by run().

Here is the call graph for this function:

Here is the caller 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 224 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 245 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:

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 728 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)
      {
        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 (GNUNET_YES !=
            GNUNET_CLIENT_test (cfg,
                                "arm"))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                      "GNUnet not running, cannot stop the peer\n");
        }
        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)
      {
        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)
      {
        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, cfg, end, GNUNET_ARM_request_service_list(), GNUNET_ARM_request_service_start(), GNUNET_ARM_request_service_stop(), GNUNET_CLIENT_test(), 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(), GNUNET_YES, h, init, init_callback(), list, list_callback(), monitor, no_stderr, no_stdout, op, phase, quiet, restart, 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.

Termiantes 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 302 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 332 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 375 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 431 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 478 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 *  list  )

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 531 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 == list)
  {
    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 (list[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",
               list[i].name,
               list[i].binary);
      break;
    default:
      GNUNET_break_op (0);
      fprintf (stdout,
               "%s (binary='%s', status=unknown)\n",
               list[i].name,
               list[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 (list[i].status)
    {
    case GNUNET_ARM_SERVICE_STATUS_STOPPED:
      if (show_all)
        fprintf (stdout,
                 "%s (binary='%s', status=stopped)\n",
                 list[i].name,
                 list[i].binary);
      break;
    case GNUNET_ARM_SERVICE_STATUS_FAILED:
      restart_in = GNUNET_TIME_absolute_get_remaining (list[i].restart_at);
      fprintf (stdout,
               "%s (binary='%s', status=failed, exit_status=%d, restart_delay='%s')\n",
               list[i].name,
               list[i].binary,
               list[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",
               list[i].name,
               list[i].binary);
      break;
    case GNUNET_ARM_SERVICE_STATUS_STARTED:
      fprintf (stdout,
               "%s (binary='%s', status=started)\n",
               list[i].name,
               list[i].binary);
      break;
    case GNUNET_ARM_SERVICE_STATUS_STOPPING:
      fprintf (stdout,
               "%s (binary='%s', status=stopping)\n",
               list[i].name,
               list[i].binary);
      break;
    default:
      GNUNET_break_op (0);
      fprintf (stdout,
               "%s (binary='%s', status=unknown)\n",
               list[i].name,
               list[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, list, 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 848 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 899 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 917 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, consensus-simulation::args, 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 main().

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

Definition at line 969 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 !=
      GNUNET_STRINGS_get_utf8_args (argc,
                                    argv,
                                    &argc,
                                    &argv))
    return 2;
  if (GNUNET_OK ==
      (lret = GNUNET_PROGRAM_run (
         argc,
         argv,
         "gnunet-arm",
         gettext_noop (
           "Control services and the Automated Restart Manager (ARM)"),
         options,
         &run,
         NULL)))
  {
    GNUNET_free_nz ((void *) argv);
    return ret;
  }
  GNUNET_free_nz ((void *) argv);
  return lret;
}

References end, gettext_noop, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), init, list, monitor, no_stderr, no_stdout, options, quiet, restart, ret, run(), show_all, start, term, and timeout.

Here is the call graph for this function:

Variable Documentation

end

int end

static

Set if we are to shutdown all services (including ARM).

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

Referenced by action_loop(), add_address_to_hello(), attach_path(), auth_key_to_string(), channel_to_sh(), check_member_session_completion(), cmd_read(), compute_policy(), dump_buffer(), expand_dollar(), extend_path(), gen_topo_from_file(), get_path_from_PATH(), get_serialization_short_name(), GNUNET_CONFIGURATION_iterate_value_filenames(), GNUNET_CRYPTO_ecdsa_private_key_to_string(), GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_CRYPTO_eddsa_private_key_to_string(), GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_DISK_pipe_close(), GNUNET_GNSRECORD_z2s(), GNUNET_HELLO_address_allocate(), GNUNET_HELLO_builder_from_block(), GNUNET_NETWORK_shorten_unixpath(), GNUNET_PG_get_event_notify_channel(), GNUNET_STRINGS_check_filename(), GNUNET_STRINGS_parse_ipv4_policy(), GNUNET_TESTING_get_trait(), handle_get(), is_excluded_generation(), main(), manage_subscribe(), needs_parentheses(), nfa_add_alternation(), nfa_add_label(), nfa_add_question_op(), nfa_add_star_op(), nfa_fragment_create(), output_message(), pool_get(), process_helper_msgs(), process_incoming(), REGEX_TEST_automaton_save_graph(), remove_parentheses(), run(), shutdown_task(), stop_callback(), transmit_item(), and uri_sks_parse().

start

int start

static

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

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

Referenced by action_loop(), add_record(), block_align(), check_iteration_start(), check_member_session_completion(), check_tcp_remote(), check_tcp_service(), compute_policy(), dfa_add_multi_strides_helper(), dfa_compress_paths_helper(), expand_dollar(), extract_address(), GNUNET_CONSENSUS_create(), GNUNET_DNSPARSER_builder_add_name(), GNUNET_FRIENDS_parse(), GNUNET_FS_queue_(), GNUNET_SECRETSHARING_create_session(), GNUNET_SECRETSHARING_decrypt(), GNUNET_STRINGS_buffer_tokenize(), GNUNET_STRINGS_parse_ipv6_policy(), GNUNET_TESTBED_operation_create_(), GNUNET_TESTBED_peer_manage_service(), GSF_update_datastore_delay_(), handle_client_start(), handle_monitor_start(), handle_tcp_remote(), handle_tcp_service(), ibf_read_slice(), ibf_write_slice(), is_excluded_generation(), main(), nfa_add_alternation(), nfa_add_label(), nfa_add_question_op(), nfa_add_star_op(), nfa_fragment_create(), pack_counter(), parse_definitions(), REGEX_INTERNAL_automaton_traverse(), REGEX_TEST_automaton_save_graph(), run(), solve_srv_room_member_collisions(), start_callback(), stop_callback(), tcp_address_to_sockaddr(), try_ifconfig(), udp_address_to_sockaddr(), and unpack_counter().

restart

int restart

static

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

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

Referenced by action_loop(), main(), and stop_callback().

delete

int delete

static

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

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

quiet

int quiet

static

Set if we should not print status messages.

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

Referenced by action_loop(), list_callback(), main(), and srv_status().

show_all

int show_all

static

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

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

Referenced by list_callback(), and main().

monitor

int monitor

static

Monitor ARM activity.

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

Referenced by action_loop(), client_disconnect_cb(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), main(), and run().

list

int list

static

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

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

Referenced by action_loop(), check_ipv4_listed(), check_ipv6_listed(), check_member_session_completion(), httpdomain.httpdomain.HTTPDomain::clear_doc(), pydiffer::dc_getdiff(), httpdomain.autohttp.tornado::get_routes(), GNUNET_CONFIGURATION_iterate_value_filenames(), handle_arm_list_result(), key_from_sexp(), list_callback(), main(), open_device(), print_peer_list(), render_row(), and consensus-simulation::simulate().

init

char* init

static

Set to the name of a service to start.

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

Referenced by action_loop(), GNUNET_CORE_connect(), GNUNET_PLUGIN_load(), handle_init_reply(), init_callback(), main(), reconnect(), and validate_dv_initiator_signature().

term

char* term

static

Set to the name of a service to kill.

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

Referenced by action_loop(), main(), and term_callback().

config_file

char* config_file

static

Set to the name of the config file used.

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

Referenced by delete_files(), GNUNET_CONFIGURATION_config_tool_run(), LEGACY_SERVICE_run(), load_member(), load_member_session(), load_member_session_next(), run(), save_member(), and set_cont().

dir

char* dir

static

Set to the directory where runtime files are stored.

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

Referenced by delete_files(), destroy_direction(), dir_init(), dir_ready_cb(), discard_all_from_rung_tail(), discard_buffer(), get_room_data_subdir(), get_srv_handle_data_subdir(), GNUNET_FS_download_sync_(), GNUNET_FS_file_information_add(), GNUNET_FS_file_information_inspect(), logger_run(), lower_rung(), route_message(), and run().

ret

int ret

static

Final status code.

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

Referenced by list_callback(), main(), and timeout_task_cb().

h

struct GNUNET_ARM_Handle* h

static

Connection with ARM.

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

Referenced by action_loop(), add_get_request_to_pending(), add_setter_action(), addr_cb(), cadet_connect_adapter(), cadet_mq_send_impl(), call_flush_completion(), change_service(), check_info(), check_key_type(), clean_node(), connect_peer(), core_mq_send_impl(), crc_init(), create_channel(), create_download_context(), deserialization_master(), deserialize_download(), deserialize_download_file(), deserialize_fi_node(), deserialize_file_information(), deserialize_publish_file(), deserialize_search(), deserialize_search_file(), deserialize_unindex_file(), destroy_channel(), disconnect(), disconnect_after_drop(), disconnect_and_free_peer_entry(), disconnect_and_schedule_reconnect(), disconnect_on_mq_error(), dispatch_buffer(), do_destroy(), do_disconnect(), do_reconnect(), encrypt_fair(), env_delete_notify(), final_disconnect(), find_channel(), find_op_by_id(), find_port(), find_qe(), find_zi(), force_reconnect(), free_ait(), free_ego(), free_it(), free_qe(), free_queue_entry(), free_ze(), full_recursive_download(), GCD_search(), GCD_search_stop(), get_fair_encryption_challenge(), get_op_id(), get_queue_head(), get_read_handle(), get_serialization_file_name(), get_serialization_file_name_in_dir(), get_update_information_directory(), get_write_handle(), get_write_handle_in_dir(), GN_start_gnunet_nat_server_(), GN_stop_gnunet_nat_server_(), GNUNET_ARM_connect(), GNUNET_ARM_disconnect(), GNUNET_ARM_monitor_start(), GNUNET_ARM_monitor_stop(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_request_service_list(), GNUNET_ARM_request_service_start(), GNUNET_ARM_request_service_stop(), GNUNET_BIO_flush(), GNUNET_BIO_read(), GNUNET_BIO_read_close(), GNUNET_BIO_read_double(), GNUNET_BIO_read_float(), GNUNET_BIO_read_int32(), GNUNET_BIO_read_int64(), GNUNET_BIO_read_open_buffer(), GNUNET_BIO_read_open_file(), GNUNET_BIO_read_set_error(), GNUNET_BIO_read_spec_commit(), GNUNET_BIO_read_spec_double(), GNUNET_BIO_read_spec_int32(), GNUNET_BIO_read_spec_object(), GNUNET_BIO_read_spec_string(), GNUNET_BIO_read_string(), GNUNET_BIO_write(), GNUNET_BIO_write_double(), GNUNET_BIO_write_float(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_open_file(), GNUNET_BIO_write_spec_double(), GNUNET_BIO_write_spec_int32(), GNUNET_BIO_write_spec_object(), GNUNET_BIO_write_spec_string(), GNUNET_BIO_write_string(), GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_connect(), GNUNET_CADET_open_port(), GNUNET_CORE_connect(), GNUNET_CORE_get_mq(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_edx25519_private_key_derive(), GNUNET_CRYPTO_edx25519_public_key_derive(), GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_hash_count_tailing_zeros(), GNUNET_DATACACHE_destroy(), GNUNET_DATACACHE_get(), GNUNET_DATACACHE_get_closest(), GNUNET_DATASTORE_cancel(), GNUNET_DATASTORE_connect(), GNUNET_DATASTORE_disconnect(), GNUNET_DATASTORE_get_for_replication(), GNUNET_DATASTORE_get_key(), GNUNET_DATASTORE_get_zero_anonymity(), GNUNET_DATASTORE_put(), GNUNET_DATASTORE_release_reserve(), GNUNET_DATASTORE_remove(), GNUNET_DATASTORE_reserve(), GNUNET_DISK_file_get_identifiers(), GNUNET_DISK_file_map(), GNUNET_DISK_file_read(), GNUNET_DISK_file_read_non_blocking(), GNUNET_DISK_file_write(), GNUNET_DISK_file_write_blocking(), GNUNET_DNSPARSER_hex_to_bin(), GNUNET_FS_dequeue_(), GNUNET_FS_download_start(), GNUNET_FS_download_start_from_search(), GNUNET_FS_end_top(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_data(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_get_indexed_files(), GNUNET_FS_make_top(), GNUNET_FS_namespace_list_updateable(), GNUNET_FS_probe(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), GNUNET_FS_publish_start(), GNUNET_FS_queue_(), GNUNET_FS_read_meta_data(), GNUNET_FS_read_spec_meta_data(), GNUNET_FS_remove_sync_dir_(), GNUNET_FS_remove_sync_file_(), GNUNET_FS_search_make_status_(), GNUNET_FS_search_start(), GNUNET_FS_stop(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_FS_tree_encoder_create(), GNUNET_FS_unindex_start(), GNUNET_FS_write_spec_meta_data(), GNUNET_HELLO_builder_from_msg(), GNUNET_HELLO_is_friend_only(), GNUNET_HELPER_destroy(), GNUNET_HELPER_kill(), GNUNET_HELPER_send(), GNUNET_HELPER_send_cancel(), GNUNET_HELPER_start(), GNUNET_HELPER_stop(), GNUNET_HELPER_wait(), GNUNET_IDENTITY_connect(), GNUNET_IDENTITY_create(), GNUNET_IDENTITY_delete(), GNUNET_IDENTITY_rename(), GNUNET_NAMECACHE_block_cache(), GNUNET_NAMECACHE_cancel(), GNUNET_NAMECACHE_connect(), GNUNET_NAMECACHE_disconnect(), GNUNET_NAMECACHE_lookup_block(), GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_records_edit(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_records_lookup2(), GNUNET_NAMESTORE_records_store(), GNUNET_NAMESTORE_records_store2(), GNUNET_NAMESTORE_transaction_begin(), GNUNET_NAMESTORE_transaction_commit(), GNUNET_NAMESTORE_transaction_rollback(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_NETWORK_fdset_handle_isset(), GNUNET_NETWORK_fdset_handle_set(), GNUNET_NETWORK_fdset_handle_set_first(), GNUNET_NSE_connect(), GNUNET_NSE_disconnect(), GNUNET_OP_add(), GNUNET_OP_destroy(), GNUNET_OP_get(), GNUNET_OP_get_next_id(), GNUNET_OP_remove(), GNUNET_OP_result(), GNUNET_PEERINFO_add_peer(), GNUNET_PEERINFO_connect(), GNUNET_PEERINFO_disconnect(), GNUNET_PEERINFO_iterate(), GNUNET_PEERINFO_iterate_cancel(), GNUNET_PEERSTORE_connect(), GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_iterate(), GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_store_cancel(), GNUNET_PEERSTORE_watch(), GNUNET_PEERSTORE_watch_cancel(), GNUNET_PQ_query_param_array_abs_time(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_cancel(), GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_credential_delete(), GNUNET_RECLAIM_credential_store(), GNUNET_RECLAIM_disconnect(), GNUNET_RECLAIM_get_attributes_next(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_RECLAIM_get_attributes_stop(), GNUNET_RECLAIM_get_credentials_next(), GNUNET_RECLAIM_get_credentials_start(), GNUNET_RECLAIM_get_credentials_stop(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RECLAIM_ticket_iteration_next(), GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_RECLAIM_ticket_iteration_stop(), GNUNET_RECLAIM_ticket_revoke(), GNUNET_REVOCATION_revoke(), GNUNET_REVOCATION_revoke_cancel(), GNUNET_RPS_connect(), GNUNET_RPS_disconnect(), GNUNET_RPS_request_cancel(), GNUNET_RPS_request_single_info_cancel(), GNUNET_RPS_seed_ids(), GNUNET_RPS_sub_start(), GNUNET_RPS_sub_stop(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_cancel(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SECRETSHARING_encrypt(), GNUNET_STATISTICS_create(), GNUNET_STATISTICS_destroy(), GNUNET_TESTBED_barrier_wait(), GNUNET_TESTBED_barrier_wait_cancel(), GNUNET_TESTBED_host_queue_oc_(), GNUNET_TESTBED_is_host_habitable(), GNUNET_TESTBED_LOGGER_connect(), GNUNET_TESTBED_LOGGER_disconnect(), GNUNET_TESTBED_LOGGER_flush(), GNUNET_TESTBED_LOGGER_flush_cancel(), GNUNET_TESTBED_LOGGER_write(), GNUNET_TESTBED_run_get_controller_handle(), GNUNET_TESTBED_SD_add_data_(), GNUNET_TESTBED_SD_destroy_(), GNUNET_TESTBED_SD_deviation_factor_(), GNUNET_TESTBED_SD_init_(), GNUNET_TRANSPORT_core_connect(), GNUNET_TRANSPORT_manipulation_connect(), GST_neighbour_get_connection(), GST_neighbour_get_connection_cancel(), habitability_check(), handle_arm_list_result(), handle_arm_result(), handle_attribute_result(), handle_block_cache_response(), handle_channel_created(), handle_channel_destroy(), handle_client_error(), handle_confirm(), handle_connect(), handle_connect_notify(), handle_consume_ticket_result(), handle_credential_result(), handle_data(), handle_data_end(), handle_disconnect(), handle_disconnect_confirm(), handle_disconnect_notify(), handle_end_iteration(), handle_estimate(), handle_identity_result_code(), handle_identity_update(), handle_info(), handle_init_reply(), handle_iterate_end(), handle_iterate_result(), handle_local_ack(), handle_local_data(), handle_lookup_block_response(), handle_lookup_result(), handle_monitor_notify(), handle_mq_error(), handle_notify_inbound(), handle_record_result(), handle_record_result_end(), handle_record_store_response(), handle_recv(), handle_response(), handle_revocation_response(), handle_revoke_ticket_result(), handle_send_ok(), handle_send_ready(), handle_set_quota(), handle_statistics_end(), handle_statistics_value(), handle_statistics_watch_value(), handle_status(), handle_stream_input(), handle_success_response(), handle_tx_control_result(), handle_view_update(), handle_watch_record(), handle_zone_to_name_response(), hash_pkey_and_label(), helper_read(), helper_write(), initialize_network_handle(), make_queue_entry(), make_serialization_file_name(), make_serialization_file_name_in_dir(), mq_error_handler(), mq_send_impl(), nat_server_read(), neighbour_connect_notify_task(), neighbour_find(), notify_excess_cb(), notify_running(), notify_sent(), notify_starting(), nse_cb(), op_find(), op_result(), open_port_cb(), pre_profiler(), probe_ping_task_cb(), process_job_queue(), process_queue(), process_result_message(), process_status_message(), read_from_buffer(), read_from_file(), read_update_information_graph(), reconnect(), reconnect_arm(), reconnect_arm_later(), reconnect_arm_monitor(), reconnect_arm_monitor_later(), reconnect_arm_monitor_task(), reconnect_arm_task(), reconnect_cbk(), reconnect_later(), reconnect_task(), records_lookup(), regex_cancel_dht_get(), REGEX_INTERNAL_announce(), REGEX_INTERNAL_announce_cancel(), REGEX_INTERNAL_reannounce(), REGEX_INTERNAL_search(), REGEX_INTERNAL_search_cancel(), regex_iterator(), remove_sync_file_in_dir(), reschedule_connect(), restart_nat_server(), restart_task(), reversal_cb(), revocation_mq_error_handler(), rewatch_it(), rps_connect_adapter(), rps_disconnect_adapter(), run(), schedule_action(), schedule_watch_request(), search_start(), send_get(), send_ic_request(), send_monitor_start(), send_transaction_control_msg(), service_connect_comp(), shutdown_service(), shutdown_task(), socket_set_inheritable(), socket_set_nodelay(), start_helper(), start_probe_ping_task(), stop_helper(), t_hmac_derive_key(), test_run(), trigger_flush_notification(), try_again(), try_anat(), try_connect(), try_reconnect(), update_memory_statistics(), and write_to_buffer().

m

struct GNUNET_ARM_MonitorHandle* m

static

Monitor connection with ARM.

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

Referenced by address_to_regex(), api_send(), check_address_add(), check_client_join(), check_encrypted(), check_request_hello_validation(), decrypt_conclude(), deliver_message(), destroy_it(), do_send(), for_matching_monitors(), full_recursive_download(), GAS_handle_address_add(), GAS_handle_address_destroyed(), GAS_handle_address_update(), gen_topo_scale_free(), get_action(), GNUNET_ATS_address_destroy(), GNUNET_ATS_address_update(), GNUNET_ATS_performance_change_preference(), GNUNET_ATS_performance_give_feedback(), GNUNET_ATS_performance_list_addresses(), GNUNET_ATS_reserve_bandwidth(), GNUNET_CRYPTO_paillier_decrypt(), GNUNET_CRYPTO_paillier_encrypt(), GNUNET_CRYPTO_paillier_encrypt1(), GNUNET_CURL_get_select_info(), GNUNET_DATASTORE_get_for_replication(), GNUNET_DATASTORE_get_zero_anonymity(), GNUNET_DHT_monitor_stop(), GNUNET_DISK_file_map(), GNUNET_FS_write_spec_meta_data(), GNUNET_memcmp_ct_(), GNUNET_SECRETSHARING_encrypt(), GNUNET_SET_operation_cancel(), GNUNET_SETI_operation_cancel(), GNUNET_SETU_operation_cancel(), GNUNET_TESTBED_overlay_configure_topology_va(), GNUNET_TESTBED_underlay_construct_(), GNUNET_TESTBED_underlaylinkmodel_create(), GNUNET_TESTING_calculate_num(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_xnew_array_2d_(), GNUNET_xnew_array_3d_(), GST_neighbours_calculate_receive_delay(), GST_neighbours_keepalive(), handle_ats_address_suggestion(), handle_client_join(), handle_decrypt_done(), handle_encrypted(), handle_ephemeral_key(), handle_init_reply(), handle_ping(), handle_pong(), handle_request_hello_validation(), handle_secret_ready(), horner_eval(), idx_of(), keygen_round2_conclude(), main(), map_remove_iterator(), notify_connect(), num_to_regex(), process_peer_monitoring_cb(), publish_inspector(), put_action(), response_action(), run(), send_add_address_message(), send_keepalive(), send_monitor_start(), send_msg(), send_to_client_iter(), shutdown_task(), start_helper(), transmit(), and transmit_suggestion().

cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

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

Referenced by action_loop(), run(), and shutdown_task().

phase

unsigned int phase

static

Processing stage that we are in.

Simple counter.

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

Referenced by action_loop(), main(), and phasename().

timeout

struct GNUNET_TIME_Relative timeout

static

User defined timestamp for completing operations.

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

Referenced by main(), and run().

timeout_task

struct GNUNET_SCHEDULER_Task* timeout_task

static

Task to be run on timeout.

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

Referenced by run(), shutdown_task(), and timeout_task_cb().

no_stdout

int no_stdout

static

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

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

Referenced by action_loop(), and main().

no_stderr

int no_stderr

static

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

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

Referenced by action_loop(), and main().

al_task

struct GNUNET_SCHEDULER_Task* al_task

static

Handle for the task running the action_loop().

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

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

op

struct GNUNET_ARM_Operation* op

static

Current operation.

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

Referenced by _GSS_is_element_of_operation(), _GSS_operation_destroy(), _GSS_operation_destroy2(), action_loop(), adjust_running_peers(), assign_timeslot(), begin_bf_exchange(), bind_loose_channel(), cadet_connect_cb(), callback_operation(), callback_scan_for_operations(), cancel_store_operation(), change_service(), change_state(), channel_end_cb(), channel_new_cb(), check_byzantine_bounds(), check_incoming_msg(), check_intersection_p2p_bf(), check_key_type(), check_max_differential_rounds(), check_readiness(), check_union_p2p_demand(), check_union_p2p_elements(), check_union_p2p_full_element(), check_union_p2p_ibf(), check_union_p2p_inquiry(), check_union_p2p_offer(), check_union_p2p_strata_estimator(), check_vectors(), churn_cb(), clean_peer(), cleanup_tslots(), clear_ego_store(), client_disconnect_cb(), client_release_ports(), collect_generation_garbage(), create_finished(), create_internal(), create_operation(), create_randomized_element_iterator(), decide_capacity(), decode_and_send(), defer(), delayed_put(), delete_finished(), destroy_operation(), determinate_avg_element_size_iterator(), dht_connect_cb(), dht_connected(), disconnect_cadet_peers(), do_shutdown(), enforce_add_address(), enforce_del_address(), enforce_start_preference(), enforce_start_property(), enforce_start_request(), enforce_stop_preference(), enforce_stop_property(), enforce_stop_request(), exop_check(), exop_insert(), fail_intersection_operation(), fail_union_operation(), filter_all(), filtered_map_initialization(), finished_local_operations(), free_op(), full_sync_plausibility_check(), GCCH_channel_incoming_new(), GCCH_channel_local_new(), get_incoming(), GNUNET_ARM_disconnect(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_request_service_list(), GNUNET_ARM_request_service_start(), GNUNET_ARM_request_service_stop(), GNUNET_IDENTITY_cancel(), GNUNET_IDENTITY_create(), GNUNET_IDENTITY_delete(), GNUNET_IDENTITY_rename(), GNUNET_OP_add(), GNUNET_OP_get(), GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_cancel(), GNUNET_RECLAIM_credential_delete(), GNUNET_RECLAIM_credential_store(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_issue(), GNUNET_RECLAIM_ticket_revoke(), GNUNET_SET_create(), GNUNET_TESTBED_host_queue_oc_(), GNUNET_TESTBED_operation_activate_(), GNUNET_TESTBED_operation_begin_wait_(), GNUNET_TESTBED_operation_create_(), GNUNET_TESTBED_operation_inactivate_(), GNUNET_TESTBED_operation_mark_failed(), GNUNET_TESTBED_operation_queue_insert2_(), GNUNET_TESTBED_operation_queue_insert_(), GNUNET_TESTBED_operation_release_(), GNUNET_TESTBED_overlay_configure_topology(), GNUNET_TESTBED_overlay_configure_topology_va(), GST_connection_pool_get_handle(), handle_arm_list_result(), handle_arm_result(), handle_attribute_result(), handle_client_accept(), handle_client_cancel(), handle_client_evaluate(), handle_client_reject(), handle_consume_ticket_result(), handle_credential_result(), handle_identity_result_code(), handle_incoming_msg(), handle_intersection_p2p_bf(), handle_intersection_p2p_done(), handle_intersection_p2p_element_info(), handle_peer_create_success(), handle_port_close(), handle_port_open(), handle_revoke_ticket_result(), handle_success_response(), handle_ticket_result(), handle_union_p2p_demand(), handle_union_p2p_done(), handle_union_p2p_elements(), handle_union_p2p_full_done(), handle_union_p2p_full_element(), handle_union_p2p_ibf(), handle_union_p2p_inquiry(), handle_union_p2p_offer(), handle_union_p2p_request_full(), handle_union_p2p_send_full(), handle_union_p2p_strata_estimator(), incoming_destroy(), incoming_timeout_cb(), info_cb(), init_callback(), init_key_to_element_iterator(), initialize_key_to_element(), initialize_map_unfiltered(), intersection_accept(), intersection_channel_death(), intersection_evaluate(), intersection_op_cancel(), iterate_destroy_operations(), iterate_save_operations(), iterator_bf_create(), iterator_bf_reduce(), list_callback(), load_episode(), load_operation(), maybe_finish(), mq_error_handler(), needs_parens(), needs_parentheses(), notify_running(), notify_starting(), ogg_demux_and_decode(), ogg_init(), op_done_task(), op_find(), op_get_element(), op_register_element(), op_result(), overlay_link_completed(), packetizer(), peer_id_cb(), peer_info_cb(), post_test_op(), prepare_ibf(), prepare_ibf_iterator(), print_op(), process_bf(), process_header(), process_rq_task(), reconnect(), reconnect_arm_later(), remove_parentheses(), remove_queue_entry(), reschedule_connect(), rps_connect_complete_cb(), rq_add(), rq_remove(), save_operation(), search_rcop(), send_bloomfilter(), send_client_done(), send_client_done_and_destroy(), send_client_element(), send_client_removed_element(), send_element_count(), send_full_element_iterator(), send_full_set(), send_ibf(), send_missing_full_elements_iter(), send_offers_for_key(), send_offers_iterator(), send_p2p_done(), send_remaining_elements(), service_connect_comp(), shutdown_task(), solver_info_cb(), start_callback(), start_operation(), stat_complete_cb(), statistics_done_cb(), stop_callback(), stop_operation(), term_callback(), union_accept(), union_channel_death(), union_evaluate(), union_op_cancel(), update_tslots(), and use_store_operation().