GNUnet  0.11.x
Functions | Variables
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_Handleh
 Connection with ARM. More...
 
static struct GNUNET_ARM_MonitorHandlem
 Monitor connection with ARM. More...
 
static struct GNUNET_CONFIGURATION_Handlecfg
 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_Tasktimeout_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_Taskal_task
 Handle for the task running the action_loop(). More...
 
static struct GNUNET_ARM_Operationop
 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.

153 {
154  GNUNET_log (
156  "Will attempt to remove configuration file %s and service directory %s\n",
157  config_file,
158  dir);
159  if (0 != unlink (config_file))
160  {
162  _ ("Failed to remove configuration file %s\n"),
163  config_file);
164  }
166  {
168  _ ("Failed to remove servicehome directory %s\n"),
169  dir);
170  }
171 }
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
#define GNUNET_log(kind,...)
@ GNUNET_OK
Definition: gnunet_common.h:95
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1085
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

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
clsclosure, unused

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

182 {
183  (void) cls;
184  if (NULL != al_task)
185  {
187  al_task = NULL;
188  }
189  if (NULL != op)
190  {
192  op = NULL;
193  }
194  if (NULL != h)
195  {
197  h = NULL;
198  }
199  if (NULL != m)
200  {
202  m = NULL;
203  }
204  if (NULL != timeout_task)
205  {
207  timeout_task = NULL;
208  }
209  if ( (GNUNET_YES == end) &&
210  (GNUNET_YES == delete) )
211  delete_files ();
213  cfg = NULL;
214 }
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static void delete_files()
Attempts to delete configuration file and GNUNET_HOME on ARM shutdown provided the end and delete opt...
Definition: gnunet-arm.c:152
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static struct GNUNET_SCHEDULER_Task * al_task
Handle for the task running the action_loop().
Definition: gnunet-arm.c:139
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run on timeout.
Definition: gnunet-arm.c:124
@ GNUNET_YES
Definition: gnunet_common.h:97
void GNUNET_ARM_monitor_stop(struct GNUNET_ARM_MonitorHandle *h)
Disconnect from the ARM service (if connected) and destroy the context.
void GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h)
Disconnect from the ARM service (if connected) and destroy the context.
Definition: arm_api.c:602
void GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
Abort an operation.
Definition: arm_api.c:789
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972

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
rsthe request status from ARM
Returns
a string interpretation of the request status

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

225 {
226  switch (rs)
227  {
229  return _ ("Message was sent successfully");
230 
232  return _ ("We disconnected from ARM before we could send a request");
233  }
234  return _ ("Unknown request status");
235 }
@ GNUNET_ARM_REQUEST_DISCONNECTED
We disconnected from ARM, and request was not sent.
@ GNUNET_ARM_REQUEST_SENT_OK
Message was sent successfully.

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
resultthe arm result
Returns
a string interpretation

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

246 {
247  switch (result)
248  {
250  return _ ("is stopped");
251 
253  return _ ("is starting");
254 
256  return _ ("is stopping");
257 
259  return _ ("is starting already");
260 
262  return _ ("is stopping already");
263 
265  return _ ("is started already");
266 
268  return _ ("is stopped already");
269 
271  return _ ("service is not known to ARM");
272 
274  return _ ("service failed to start");
275 
277  return _ ("service cannot be manipulated because ARM is shutting down");
278  }
279  return _ ("Unknown result code.");
280 }
static int result
Global testing status.
@ GNUNET_ARM_RESULT_IS_NOT_KNOWN
Asked to start or stop a service, but it's not known.
@ GNUNET_ARM_RESULT_IS_STARTING_ALREADY
Asked to start it, but it's already starting.
@ GNUNET_ARM_RESULT_IS_STOPPED_ALREADY
Asked to stop it, but it's already stopped.
@ GNUNET_ARM_RESULT_STARTING
Service starting was initiated.
@ GNUNET_ARM_RESULT_IS_STARTED_ALREADY
Asked to start it, but it's already started.
@ GNUNET_ARM_RESULT_STOPPING
ARM stopping was initiated (there's no "stopped" for ARM itself).
@ GNUNET_ARM_RESULT_IS_STOPPING_ALREADY
Asked to stop it, but it's already stopping.
@ GNUNET_ARM_RESULT_STOPPED
Service was stopped (never sent for ARM itself).
@ GNUNET_ARM_RESULT_START_FAILED
Tried to start a service, but that failed for some reason.
@ GNUNET_ARM_RESULT_IN_SHUTDOWN
Asked to start something, but ARM is shutting down and can't comply.

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
clsclosure

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

Parameters
clsclosure, unused

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

729 {
730  (void) cls;
731  al_task = NULL;
733  "Running requested actions\n");
734  while (1)
735  {
736  switch (phase++)
737  {
738  case 0:
739  if (NULL != term)
740  {
742  "Termination action\n");
744  term,
745  &term_callback,
746  NULL);
747  return;
748  }
749  break;
750 
751  case 1:
752  if (end || restart)
753  {
754  if (GNUNET_YES !=
756  "arm"))
757  {
759  "GNUnet not running, cannot stop the peer\n");
760  }
761  else
762  {
764  "End action\n");
766  "arm",
767  &stop_callback,
768  NULL);
769  return;
770  }
771  }
772  break;
773 
774  case 2:
775  if (start)
776  {
778  "Start action\n");
779  op =
781  "arm",
782  (no_stdout
783  ? 0
785  | (no_stderr
786  ? 0
789  NULL);
790  return;
791  }
792  break;
793 
794  case 3:
795  if (NULL != init)
796  {
798  "Initialization action\n");
800  init,
802  &init_callback,
803  NULL);
804  return;
805  }
806  break;
807 
808  case 4:
809  if (list)
810  {
812  "Going to list all running services controlled by ARM.\n");
814  &list_callback,
815  &list);
816  return;
817  }
818  break;
819 
820  case 5:
821  if (monitor)
822  {
823  if (! quiet)
824  fprintf (stderr,
825  _ ("Now only monitoring, press CTRL-C to stop.\n"));
826  quiet =
827  0; /* does not make sense to stay quiet in monitor mode at this time */
828  return; /* done with tasks, just monitor */
829  }
830  break;
831 
832  default: /* last phase */
834  return;
835  }
836  }
837 }
static int no_stdout
Do we want to give our stdout to gnunet-service-arm?
Definition: gnunet-arm.c:129
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.
Definition: gnunet-arm.c:478
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static int monitor
Monitor ARM activity.
Definition: gnunet-arm.c:64
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69
static int quiet
Set if we should not print status messages.
Definition: gnunet-arm.c:54
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.
Definition: gnunet-arm.c:375
static char * term
Set to the name of a service to kill.
Definition: gnunet-arm.c:79
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
static int restart
Set if we are to stop/start default services (including ARM).
Definition: gnunet-arm.c:44
static unsigned int phase
Processing stage that we are in.
Definition: gnunet-arm.c:114
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.
Definition: gnunet-arm.c:531
static int no_stderr
Do we want to give our stderr to gnunet-service-arm?
Definition: gnunet-arm.c:134
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.
Definition: gnunet-arm.c:431
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.
Definition: gnunet-arm.c:332
struct GNUNET_ARM_Operation * GNUNET_ARM_request_service_start(struct GNUNET_ARM_Handle *h, const char *service_name, enum GNUNET_OS_InheritStdioFlags std_inheritance, GNUNET_ARM_ResultCallback cont, void *cont_cls)
Request for a service to be started.
Definition: arm_api.c:925
struct GNUNET_ARM_Operation * GNUNET_ARM_request_service_stop(struct GNUNET_ARM_Handle *h, const char *service_name, GNUNET_ARM_ResultCallback cont, void *cont_cls)
Request a service to be stopped.
Definition: arm_api.c:1037
struct GNUNET_ARM_Operation * GNUNET_ARM_request_service_list(struct GNUNET_ARM_Handle *h, GNUNET_ARM_ServiceListCallback cont, void *cont_cls)
Request a list of running services.
Definition: arm_api.c:1072
int GNUNET_CLIENT_test(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name)
Test if the port or UNIXPATH of the given service_name is in use and thus (most likely) the respectiv...
Definition: client.c:899
@ GNUNET_OS_INHERIT_STD_OUT
When this flag is set, the child process will inherit stdout of the parent.
Definition: gnunet_os_lib.h:85
@ GNUNET_OS_INHERIT_STD_ERR
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:91
@ GNUNET_OS_INHERIT_STD_NONE
No standard streams should be inherited.
Definition: gnunet_os_lib.h:73
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531

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
clsclosure
connectedGNUNET_YES if connected, GNUNET_NO if disconnected, GNUNET_SYSERR on error.

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

304 {
305  static int once;
306 
307  (void) cls;
308  if ( (GNUNET_SYSERR == connected) &&
309  (0 == once) )
310  {
312  _ ("Fatal error initializing ARM API.\n"));
314  return;
315  }
316  once = 1;
317 }
static int once
Global to mark if we've run the initialization.
Definition: gnsrecord.c:68
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
@ GNUNET_ERROR_TYPE_ERROR

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
clsclosure unused
rswhat happened to our request
resultif the request was processed, this is the result according to ARM

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

335 {
336  (void) cls;
337  op = NULL;
338  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
339  {
340  fprintf (stdout,
341  _ ("Failed to start the ARM service: %s\n"),
342  req_string (rs));
344  return;
345  }
348  {
349  fprintf (stdout,
350  _ ("Failed to start the ARM service: %s\n"),
351  ret_string (result));
353  return;
354  }
356  "ARM service [re]start successful\n");
357  start = 0;
359  NULL);
360 }
static const char * req_string(enum GNUNET_ARM_RequestStatus rs)
Returns a string interpretation of rs.
Definition: gnunet-arm.c:224
static void action_loop(void *cls)
Main task that runs our various operations in order.
Definition: gnunet-arm.c:728
static const char * ret_string(enum GNUNET_ARM_Result result)
Returns a string interpretation of the result.
Definition: gnunet-arm.c:245
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296

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
clsclosure unused
rswhat happened to our request
resultif the request was processed, this is the result according to ARM

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

378 {
379  char *msg;
380 
381  (void) cls;
382  op = NULL;
383  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
384  {
386  "%s",
387  _ (
388  "Failed to send a stop request to the ARM service: %s\n"));
389  fprintf (stdout, msg, req_string (rs));
390  GNUNET_free (msg);
392  return;
393  }
397  {
398  fprintf (stdout,
399  _ ("Failed to stop the ARM service: %s\n"),
400  ret_string (result));
402  return;
403  }
405  "ARM service shutdown successful\n");
406  end = 0;
407  if (restart)
408  {
409  restart = 0;
410  start = 1;
412  "Initiating an ARM restart\n");
413  }
415  NULL);
416 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_free(ptr)
Wrapper around free.

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
clsclosure unused
rswhat happened to our request
resultif the request was processed, this is the result according to ARM

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

434 {
435  (void) cls;
436  op = NULL;
437  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
438  {
439  fprintf (stdout,
440  _ ("Failed to send a request to start the `%s' service: %s\n"),
441  init,
442  req_string (rs));
444  return;
445  }
448  {
449  fprintf (stdout,
450  _ ("Failed to start the `%s' service: %s\n"),
451  init,
452  ret_string (result));
454  return;
455  }
457  "Service %s [re]started successfully\n",
458  init);
459  GNUNET_free (init);
460  init = NULL;
462  NULL);
463 }

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
clsclosure unused
rswhat happened to our request
resultif the request was processed, this is the result according to ARM

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

481 {
482  char *msg;
483 
484  (void) cls;
485  op = NULL;
486  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
487  {
489  _ (
490  "Failed to send a request to kill the `%s' service: %%s\n"),
491  term);
492  fprintf (stdout,
493  msg,
494  req_string (rs));
495  GNUNET_free (msg);
497  return;
498  }
499  if ( (GNUNET_ARM_RESULT_STOPPED != result) &&
501  {
502  fprintf (stdout,
503  _ ("Failed to kill the `%s' service: %s\n"),
504  term,
505  ret_string (result));
507  return;
508  }
509 
511  "Service %s stopped successfully\n",
512  term);
513  GNUNET_free (term);
514  term = NULL;
516  NULL);
517 }

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
clsclosure (unused)
rsrequest status (success, failure, etc.)
countnumber of services in the list
listlist of services managed by arm

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

535 {
536  unsigned int num_stopped = 0;
537  unsigned int num_started = 0;
538  unsigned int num_stopping = 0;
539  unsigned int num_failed = 0;
540  unsigned int num_finished = 0;
541  (void) cls;
542  op = NULL;
543  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
544  {
545  char *msg;
546 
548  "%s",
549  _ ("Failed to request a list of services: %s\n"));
550  fprintf (stdout,
551  msg,
552  req_string (rs));
553  GNUNET_free (msg);
554  ret = 3;
556  }
557  if (NULL == list)
558  {
559  fprintf (stderr,
560  "%s",
561  _ ("Error communicating with ARM. ARM not running?\n"));
563  ret = 3;
564  return;
565  }
566  for (unsigned int i = 0; i < count; i++)
567  {
568  switch (list[i].status)
569  {
571  num_stopped++;
572  break;
574  num_failed++;
575  break;
577  num_finished++;
578  break;
580  num_started++;
581  break;
583  num_stopping++;
584  fprintf (stdout,
585  "%s (binary='%s', status=stopping)\n",
586  list[i].name,
587  list[i].binary);
588  break;
589  default:
590  GNUNET_break_op (0);
591  fprintf (stdout,
592  "%s (binary='%s', status=unknown)\n",
593  list[i].name,
594  list[i].binary);
595  break;
596  }
597  }
598  if (! quiet)
599  {
600  if (show_all)
601  fprintf (stdout,
602  "%s",
603  _ ("All services:\n"));
604  else
605  fprintf (stdout,
606  "%s",
607  _ ("Services (excluding stopped services):\n"));
608  if (num_stopped || num_failed || num_finished || num_stopping ||
609  num_started)
610  {
611  int sep = 0;
612  fprintf (stdout, "(");
613  if (0 != num_started)
614  {
615  if (sep)
616  fprintf (stdout, " / ");
617  fprintf (stdout,
618  "started: %u",
619  num_started);
620  sep = 1;
621  }
622  if (0 != num_failed)
623  {
624  if (sep)
625  fprintf (stdout, " / ");
626  fprintf (stdout,
627  "failed: %u",
628  num_failed);
629  sep = 1;
630  }
631  if (0 != num_stopping)
632  {
633  if (sep)
634  fprintf (stdout, " / ");
635  fprintf (stdout,
636  "stopping: %u",
637  num_stopping);
638  sep = 1;
639  }
640  if (0 != num_stopped)
641  {
642  if (sep)
643  fprintf (stdout, " / ");
644  fprintf (stdout,
645  "stopped: %u",
646  num_stopped);
647  sep = 1;
648  }
649  if (0 != num_finished)
650  {
651  if (sep)
652  fprintf (stdout, " / ");
653  fprintf (stdout,
654  "finished: %u",
655  num_finished);
656  sep = 1;
657  }
658  fprintf (stdout, ")\n");
659  }
660  else
661  {
662  fprintf (stdout,
663  "%s",
664  _ ("(No services configured.)\n"));
665  }
666  }
667  for (unsigned int i = 0; i < count; i++)
668  {
669  struct GNUNET_TIME_Relative restart_in;
670  switch (list[i].status)
671  {
673  if (show_all)
674  fprintf (stdout,
675  "%s (binary='%s', status=stopped)\n",
676  list[i].name,
677  list[i].binary);
678  break;
680  restart_in = GNUNET_TIME_absolute_get_remaining (list[i].restart_at);
681  fprintf (stdout,
682  "%s (binary='%s', status=failed, exit_status=%d, restart_delay='%s')\n",
683  list[i].name,
684  list[i].binary,
685  list[i].last_exit_status,
687  GNUNET_YES));
688  break;
690  fprintf (stdout,
691  "%s (binary='%s', status=finished)\n",
692  list[i].name,
693  list[i].binary);
694  break;
696  fprintf (stdout,
697  "%s (binary='%s', status=started)\n",
698  list[i].name,
699  list[i].binary);
700  break;
702  fprintf (stdout,
703  "%s (binary='%s', status=stopping)\n",
704  list[i].name,
705  list[i].binary);
706  break;
707  default:
708  GNUNET_break_op (0);
709  fprintf (stdout,
710  "%s (binary='%s', status=unknown)\n",
711  list[i].name,
712  list[i].binary);
713  break;
714  }
715  }
717  NULL);
718 }
static int show_all
Set if we should print all services, including stopped ones.
Definition: gnunet-arm.c:59
static int ret
Final status code.
Definition: gnunet-arm.c:94
uint16_t status
See PRISM_STATUS_*-constants.
@ GNUNET_ARM_SERVICE_STATUS_FINISHED
The service was started, but then exited normally.
@ GNUNET_ARM_SERVICE_STATUS_FAILED
The service has previously failed, and will be restarted.
@ GNUNET_ARM_SERVICE_STATUS_STOPPED
Service is stopped.
@ GNUNET_ARM_SERVICE_STATUS_STOPPING
The service was started, and we're currently waiting for it to be stopped.
@ GNUNET_ARM_SERVICE_STATUS_STARTED
Service has been started and is currently running.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:232
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:557
const char * name
Time for relative time used by GNUnet, in microseconds.

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
clsclosure
serviceservice name
statusstatus of the service

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

851 {
852  const char *msg;
853 
854  (void) cls;
855  switch (status)
856  {
858  return; /* this should be done silently */
859 
861  msg = _ ("Stopped %s.\n");
862  break;
863 
865  msg = _ ("Starting %s...\n");
866  break;
867 
869  msg = _ ("Stopping %s...\n");
870  break;
871 
872  default:
873  msg = NULL;
874  break;
875  }
876  if (! quiet)
877  {
878  if (NULL != msg)
879  fprintf (stderr,
880  msg,
881  service);
882  else
883  fprintf (stderr,
884  _ ("Unknown status %u for service %s.\n"),
885  status,
886  service);
887  }
889  "Got service %s status %d\n",
890  service,
891  (int) status);
892 }
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
@ GNUNET_ARM_SERVICE_STOPPING
Service stopping was initiated.
@ GNUNET_ARM_SERVICE_STOPPED
Service was stopped.
@ GNUNET_ARM_SERVICE_STARTING
Service starting was initiated.
@ GNUNET_ARM_SERVICE_MONITORING_STARTED
Dummy message.

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.

900 {
901  (void) cls;
902  timeout_task = NULL;
903  ret = 2;
905 }

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
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cconfiguration

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

921 {
922  (void) cls;
923  (void) args;
924  (void) cfgfile;
926  if (GNUNET_OK !=
928  "PATHS",
929  "GNUNET_HOME",
930  &dir))
931  {
933  "PATHS",
934  "GNUNET_HOME");
935  return;
936  }
938  "arm",
939  "CONFIG",
940  &config_file);
941  if (NULL == (h = GNUNET_ARM_connect (cfg,
942  &conn_status,
943  NULL)))
944  return;
945  if (monitor)
947  &srv_status,
948  NULL);
950  NULL);
952  NULL);
953  if (0 != timeout.rel_value_us)
954  timeout_task =
957  NULL);
958 }
static void timeout_task_cb(void *cls)
Task run on timeout (if -T is given).
Definition: gnunet-arm.c:899
static void shutdown_task(void *cls)
Main continuation-passing-style loop.
Definition: gnunet-arm.c:181
static void conn_status(void *cls, int connected)
Function called whenever we connect to or disconnect from ARM.
Definition: gnunet-arm.c:302
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:119
static void srv_status(void *cls, const char *service, enum GNUNET_ARM_ServiceMonitorStatus status)
Function called when a service starts or stops.
Definition: gnunet-arm.c:848
struct GNUNET_ARM_Handle * GNUNET_ARM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ARM_ConnectionStatusCallback conn_status, void *conn_status_cls)
Set up a context for communicating with ARM, then start connecting to the ARM service using that cont...
Definition: arm_api.c:577
struct GNUNET_ARM_MonitorHandle * GNUNET_ARM_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ARM_ServiceMonitorCallback cont, void *cont_cls)
Setup a context for monitoring ARM, then start connecting to the ARM service for monitoring using tha...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1331
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
uint64_t rel_value_us
The actual value.

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
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error, 2 on timeout

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

970 {
973  "end",
974  gettext_noop ("stop all GNUnet services"),
975  &end),
977  "init",
978  "SERVICE",
979  gettext_noop ("start a particular service"),
980  &init),
982  "kill",
983  "SERVICE",
984  gettext_noop ("stop a particular service"),
985  &term),
987  "all",
988  gettext_noop (
989  "also show stopped services (used with -I)"),
990  &show_all),
992  "start",
993  gettext_noop (
994  "start all GNUnet default services"),
995  &start),
997  "restart",
998  gettext_noop (
999  "stop and start all GNUnet default services"),
1000  &restart),
1002  "delete",
1003  gettext_noop (
1004  "delete config file and directory on exit"),
1005  &delete),
1007  "monitor",
1008  gettext_noop ("monitor ARM activities"),
1009  &monitor),
1011  "quiet",
1012  gettext_noop ("don't print status messages"),
1013  &quiet),
1015  'T',
1016  "timeout",
1017  "DELAY",
1018  gettext_noop (
1019  "exit with error status if operation does not finish after DELAY"),
1020  &timeout),
1022  "info",
1023  gettext_noop (
1024  "list currently running services"),
1025  &list),
1027  'O',
1028  "no-stdout",
1029  gettext_noop ("don't let gnunet-service-arm inherit standard output"),
1030  &no_stdout),
1032  'E',
1033  "no-stderr",
1034  gettext_noop ("don't let gnunet-service-arm inherit standard error"),
1035  &no_stderr),
1037  };
1038  int lret;
1039 
1040  if (GNUNET_OK !=
1042  argv,
1043  &argc,
1044  &argv))
1045  return 2;
1046  if (GNUNET_OK ==
1047  (lret = GNUNET_PROGRAM_run (
1048  argc,
1049  argv,
1050  "gnunet-arm",
1051  gettext_noop (
1052  "Control services and the Automated Restart Manager (ARM)"),
1053  options,
1054  &run,
1055  NULL)))
1056  {
1057  GNUNET_free_nz ((void *) argv);
1058  return ret;
1059  }
1060  GNUNET_free_nz ((void *) argv);
1061  return lret;
1062 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
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.
Definition: gnunet-arm.c:917
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time).
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
#define GNUNET_free_nz(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:364
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1209
Definition of a command line option.

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

◆ start

int start
static

◆ 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(), main(), and run().

◆ list

int list
static

◆ init

char* init
static

◆ 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

◆ dir

char* dir
static

◆ 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_setter_action(), addr_cb(), cadet_connect_adapter(), cadet_mq_send_impl(), call_flush_completion(), change_service(), check_info(), 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_get_buffer_contents(), 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_meta_data(), GNUNET_BIO_read_open_buffer(), GNUNET_BIO_read_open_file(), GNUNET_BIO_read_spec_commit(), GNUNET_BIO_read_spec_double(), GNUNET_BIO_read_spec_int32(), GNUNET_BIO_read_spec_meta_data(), GNUNET_BIO_read_spec_object(), GNUNET_BIO_read_spec_string(), GNUNET_BIO_read_string(), GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_double(), GNUNET_BIO_write_float(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_open_buffer(), GNUNET_BIO_write_open_file(), GNUNET_BIO_write_spec_double(), GNUNET_BIO_write_spec_int32(), GNUNET_BIO_write_spec_meta_data(), 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_DATACACHE_destroy(), GNUNET_DATACACHE_get(), GNUNET_DATACACHE_get_closest(), GNUNET_DATACACHE_get_random(), GNUNET_DATACACHE_put(), 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_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_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_disconnect(), GNUNET_IDENTITY_get(), GNUNET_IDENTITY_rename(), GNUNET_IDENTITY_set(), 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_lookup(), GNUNET_NAMESTORE_records_store(), GNUNET_NAMESTORE_zone_iteration_start(), 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_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_dht_p2p_result(), handle_disconnect(), handle_disconnect_confirm(), handle_disconnect_notify(), handle_end_iteration(), handle_estimate(), handle_identity_result_code(), handle_identity_set_default(), 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_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(), 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_get_known_results(), send_ic_request(), send_monitor_start(), 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(), write_to_buffer(), and write_to_file().

◆ 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(), calculate_num(), check_address_add(), check_client_join(), check_encrypted(), check_request_hello_validation(), decrypt_conclude(), deliver_message(), destroy_it(), do_send(), full_recursive_download(), GAS_handle_address_add(), GAS_handle_address_destroyed(), GAS_handle_address_update(), GDS_CLIENTS_process_get(), GDS_CLIENTS_process_get_resp(), GDS_CLIENTS_process_put(), gen_topo_scale_free(), GNUNET_ABE_cpabe_decrypt(), GNUNET_ABE_cpabe_encrypt(), 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_BIO_write_meta_data(), GNUNET_BIO_write_spec_meta_data(), GNUNET_BLOCK_mingle_hash(), GNUNET_CRYPTO_cpabe_decrypt(), GNUNET_CRYPTO_cpabe_encrypt(), 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_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_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(), 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_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_disconnect(), GNUNET_IDENTITY_get(), GNUNET_IDENTITY_rename(), GNUNET_IDENTITY_set(), 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_identity_set_default(), 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().