GNUnet 0.21.0
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",
158 dir);
159 if (0 != unlink (config_file))
160 {
162 _ ("Failed to remove configuration file %s\n"),
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
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1087
#define GNUNET_log(kind,...)
@ GNUNET_OK
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

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
void GNUNET_ARM_monitor_stop(struct GNUNET_ARM_MonitorHandle *h)
Disconnect from the ARM service and destroy the handle.
void GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h)
Disconnect from the ARM service and destroy the handle.
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.
@ GNUNET_YES
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975

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,
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",
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,
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");
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:926
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:1073
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:1038
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:903
@ GNUNET_OS_INHERIT_STD_OUT
When this flag is set, the child process will inherit stdout of the parent.
Definition: gnunet_os_lib.h:89
@ GNUNET_OS_INHERIT_STD_ERR
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:95
@ GNUNET_OS_INHERIT_STD_NONE
No standard streams should be inherited.
Definition: gnunet_os_lib.h:77
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562

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:67
@ GNUNET_SYSERR
@ 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;
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"),
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:1299

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;
384 {
386 "%s",
387 _ (
388 "Failed to send a stop request to the ARM service: %s\n"));
389 fprintf (stdout, msg, req_string (rs));
392 return;
393 }
397 {
398 fprintf (stdout,
399 _ ("Failed to stop the ARM service: %s\n"),
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;
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,
454 return;
455 }
457 "Service %s [re]started successfully\n",
458 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;
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));
497 return;
498 }
501 {
502 fprintf (stdout,
503 _ ("Failed to kill the `%s' service: %s\n"),
504 term,
507 return;
508 }
509
511 "Service %s stopped successfully\n",
512 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;
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));
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
static char * name
Name (label) of the records to list.
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:38
@ 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:405
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:570
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,
943 NULL)))
944 return;
945 if (monitor)
947 &srv_status,
948 NULL);
950 NULL);
952 NULL);
953 if (0 != timeout.rel_value_us)
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.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
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.
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:1334
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:1272
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 finish_test(), get_command(), GNUNET_TESTING_command_new(), and 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",
989 "also show stopped services (used with -I)"),
990 &show_all),
992 "start",
994 "start all GNUnet default services"),
995 &start),
997 "restart",
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:70
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:400
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:1230
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

◆ start

◆ 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

◆ list

◆ init

◆ 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

◆ ret

int ret
static

Final status code.

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

Referenced by __attribute__(), add_record(), add_services(), add_to_buf(), add_valid_peer(), address_to_regex(), attr_in_claims_request(), barrier_reached_traits(), barrier_traits(), batch_traits(), block_until_external_trigger_traits(), bound_priority(), build_dns_query(), check_dht_p2p_hello(), check_signature_identity(), check_vectors(), cleanup_expired_records(), close_all_files(), cmd_read(), compute_chk_offset(), compute_policy(), compute_rand_delay(), connect_peers_traits(), conversation_value_to_string(), convert_with_table(), copy_from_reader(), create_peer_ctx(), create_response(), CustomPeerMap_remove_peer(), database_prepare(), decrypt_and_check_tc(), demultiplex_with_cmc(), deserialize_fi_node(), deserialize_file_information(), DID_create(), do_send(), download_hostlist(), execute_get(), extract_fixed_blob(), extract_rsa_pub(), extract_rsa_sig(), extract_var_blob(), fh_reader(), file_test_internal(), fork_and_exec(), GCP_2s(), GCP_iterate_indirect_paths(), GCP_iterate_paths(), GCP_iterate_paths_at(), GCT_handle_kx(), GCT_handle_kx_auth(), get_bootstrap_server(), get_cb(), get_delay_randomization(), get_first_string_value(), get_first_value(), get_key(), get_latest(), get_next_free_ctn(), get_peer_ctx(), get_random_peer_from_peermap(), get_randomized_delay(), get_read_handle(), get_records_and_call_iterator(), get_second_value(), get_serialization_file_name(), get_serialization_file_name_in_dir(), get_server_addresses(), get_transmit_delay(), get_update_information_directory(), get_valid_peers(), get_write_handle(), get_write_handle_in_dir(), getPRK(), gns_resolve_name(), GNUNET_ABD_delegates_get_size(), GNUNET_ABD_delegation_chain_get_size(), GNUNET_ABD_delegation_set_get_size(), GNUNET_ARM_request_service_start(), GNUNET_asprintf(), GNUNET_b2s(), GNUNET_BANDWIDTH_tracker_get_delay(), GNUNET_BANDWIDTH_value_get_delay_for(), GNUNET_BANDWIDTH_value_init(), GNUNET_BIO_flush(), GNUNET_BIO_get_buffer_contents(), GNUNET_BIO_read_spec_commit(), GNUNET_BIO_write_spec_commit(), GNUNET_BLOCK_group_merge(), GNUNET_CADET_get_channel_cancel(), GNUNET_CADET_get_path_cancel(), GNUNET_CADET_list_peers_cancel(), GNUNET_CADET_list_tunnels_cancel(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_deserialize(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_iterate_value_filenames(), GNUNET_CONFIGURATION_parse(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_CONFIGURATION_write_diffs(), GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap32_remove_all(), GNUNET_CONTAINER_multihashmap_clear(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_CONTAINER_multipeermap_remove_all(), GNUNET_CONTAINER_multishortmap_remove_all(), GNUNET_CONTAINER_multiuuidmap_remove_all(), GNUNET_copy_message(), GNUNET_CRYPTO_blind_sign_keys_create(), GNUNET_CRYPTO_ecdsa_fo_kem_decaps(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_eddsa_fo_kem_decaps(), GNUNET_CRYPTO_eddsa_fo_kem_encaps(), GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_count_leading_zeros(), GNUNET_CRYPTO_hash_count_tailing_zeros(), GNUNET_CRYPTO_hkdf(), GNUNET_CRYPTO_hkdf_v(), GNUNET_CRYPTO_kdf(), GNUNET_CRYPTO_private_key_from_string(), GNUNET_CRYPTO_public_key_from_string(), GNUNET_CRYPTO_random_permute(), GNUNET_CRYPTO_random_u32(), GNUNET_CRYPTO_random_u64(), GNUNET_CRYPTO_rsa_blind(), GNUNET_CRYPTO_rsa_private_key_cmp(), GNUNET_CRYPTO_rsa_private_key_create(), GNUNET_CRYPTO_rsa_public_key_check(), GNUNET_CRYPTO_rsa_public_key_cmp(), GNUNET_CRYPTO_rsa_public_key_encode(), GNUNET_CRYPTO_rsa_signature_cmp(), GNUNET_CRYPTO_rsa_signature_dup(), GNUNET_CRYPTO_rsa_signature_encode(), GNUNET_CRYPTO_rsa_unblind(), GNUNET_DATACACHE_create(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_scan(), GNUNET_DISK_directory_test(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read_non_blocking(), GNUNET_DISK_file_size(), GNUNET_DISK_file_unmap(), GNUNET_DISK_file_write_blocking(), GNUNET_DISK_fn_read(), GNUNET_DISK_glob(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_close_end(), GNUNET_DISK_pipe_detach_end(), GNUNET_DISK_pipe_from_fd(), GNUNET_DNSPARSER_bin_to_hex(), GNUNET_DNSPARSER_builder_add_query(), GNUNET_DNSPARSER_builder_add_soa(), GNUNET_DNSPARSER_builder_add_srv(), GNUNET_DNSPARSER_pack(), GNUNET_e2s(), GNUNET_e2s2(), GNUNET_FS_data_reader_file_(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_builder_create(), GNUNET_FS_directory_builder_finish(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_file(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_make_top(), GNUNET_FS_meta_data_duplicate(), GNUNET_FS_meta_data_get_first_by_types(), GNUNET_FS_meta_data_get_serialized_size(), GNUNET_FS_meta_data_suggest_filename(), GNUNET_FS_meta_data_test_for_directory(), GNUNET_FS_publish_start(), GNUNET_FS_search_make_status_(), GNUNET_FS_search_start(), GNUNET_FS_start(), GNUNET_FS_tree_calculate_block_size(), GNUNET_FS_tree_compute_iblock_size(), GNUNET_FS_uri_dup(), GNUNET_FS_uri_ksk_create_from_meta_data(), GNUNET_FS_uri_ksk_merge(), GNUNET_FS_uri_ksk_to_string_fancy(), GNUNET_FS_uri_loc_get_uri(), GNUNET_FS_uri_parse(), GNUNET_FS_uri_test_equal(), GNUNET_GNS_lookup_cancel(), GNUNET_GNS_lookup_with_tld_cancel(), GNUNET_GNSRECORD_JSON_spec_gnsrecord(), GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_GNSRECORD_pow_round(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_typename_to_number(), GNUNET_GNSRECORD_value_to_string(), GNUNET_h2s(), GNUNET_h2s2(), GNUNET_h2s_full(), GNUNET_HELLO_builder_from_block(), GNUNET_HELLO_builder_from_url(), GNUNET_HELLO_dht_msg_to_block(), GNUNET_HELPER_kill(), GNUNET_HELPER_wait(), GNUNET_i2s(), GNUNET_i2s2(), GNUNET_i2s_full(), GNUNET_JSON_from_rsa_public_key(), GNUNET_JSON_from_rsa_signature(), GNUNET_JSON_pack_(), GNUNET_JSON_post_parser(), GNUNET_JSON_spec_array_const(), GNUNET_JSON_spec_bool(), GNUNET_JSON_spec_boolean(), GNUNET_JSON_spec_double(), GNUNET_JSON_spec_end(), GNUNET_JSON_spec_fixed(), GNUNET_JSON_spec_fixed64(), GNUNET_JSON_spec_int64(), GNUNET_JSON_spec_json(), GNUNET_JSON_spec_mark_optional(), GNUNET_JSON_spec_object_const(), GNUNET_JSON_spec_relative_time(), GNUNET_JSON_spec_rsa_public_key(), GNUNET_JSON_spec_rsa_signature(), GNUNET_JSON_spec_string(), GNUNET_JSON_spec_timestamp(), GNUNET_JSON_spec_timestamp_nbo(), GNUNET_JSON_spec_uint16(), GNUNET_JSON_spec_uint32(), GNUNET_JSON_spec_uint64(), GNUNET_JSON_spec_uint8(), GNUNET_JSON_spec_varsize(), GNUNET_LOAD_value_init(), GNUNET_MQ_env_combine_options(), GNUNET_MQ_inject_message(), GNUNET_MST_create(), GNUNET_MST_from_buffer(), GNUNET_MST_read(), GNUNET_NAT_mini_map_start(), GNUNET_NAT_stun_handle_packet_(), GNUNET_NETWORK_socket_accept(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_box_native(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_disable_corking(), GNUNET_NETWORK_socket_getsockopt(), GNUNET_NETWORK_socket_listen(), GNUNET_NETWORK_socket_recv(), GNUNET_NETWORK_socket_send(), GNUNET_NETWORK_socket_shutdown(), GNUNET_NETWORK_test_pf(), GNUNET_NETWORK_test_port_free(), GNUNET_NETWORK_unix_precheck(), GNUNET_OS_process_kill(), GNUNET_OS_process_wait(), GNUNET_OS_start_process(), GNUNET_OS_start_process_va(), GNUNET_p2s(), GNUNET_p2s2(), GNUNET_PEER_intern(), GNUNET_PLUGIN_load(), GNUNET_PLUGIN_unload(), GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_exec_prepared(), GNUNET_PQ_exec_sql(), GNUNET_PQ_extract_result(), GNUNET_PQ_prepare_once(), GNUNET_PQ_reconnect(), GNUNET_PQ_run_sql(), GNUNET_PROGRAM_run2(), gnunet_read(), GNUNET_RECLAIM_attribute_number_to_typename(), GNUNET_RECLAIM_attribute_typename_to_number(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_credential_get_attributes(), GNUNET_RECLAIM_credential_get_issuer(), GNUNET_RECLAIM_credential_number_to_typename(), GNUNET_RECLAIM_credential_typename_to_number(), GNUNET_RECLAIM_credential_value_to_string(), GNUNET_RECLAIM_JSON_spec_attribute(), GNUNET_RECLAIM_JSON_spec_credential(), GNUNET_RECLAIM_JSON_spec_ticket(), GNUNET_RECLAIM_presentation_get_attributes(), GNUNET_RECLAIM_presentation_get_issuer(), GNUNET_RECLAIM_presentation_number_to_typename(), GNUNET_RECLAIM_presentation_typename_to_number(), GNUNET_RECLAIM_presentation_value_to_string(), GNUNET_RESOLVER_local_fqdn_get(), GNUNET_SCHEDULER_add_now_with_lifeness(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_get_load(), GNUNET_SERVICE_main(), GNUNET_SERVICE_run_(), GNUNET_SIGNAL_handler_install(), GNUNET_snprintf(), GNUNET_SQ_prepare(), GNUNET_STRINGS_base64_decode(), GNUNET_STRINGS_base64_encode(), GNUNET_STRINGS_base64url_decode(), GNUNET_STRINGS_byte_size_fancy(), GNUNET_STRINGS_conv(), GNUNET_STRINGS_fancy_time_to_relative(), GNUNET_STRINGS_get_suffix_from_binary_name(), GNUNET_STRINGS_parse_ipv6_policy(), GNUNET_STRINGS_string_to_data(), GNUNET_STRINGS_to_address_ipv6(), GNUNET_TESTING_get_topo_from_string(), GNUNET_TESTING_get_trait(), GNUNET_TESTING_peer_wait(), GNUNET_TESTING_reserve_port(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_from_ms(), GNUNET_TIME_absolute_from_s(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_absolute_round_down(), GNUNET_TIME_absolute_subtract(), GNUNET_TIME_calculate_eta(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_ntoh(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_TIME_relative_subtract(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_timestamp_from_s(), GNUNET_TIME_year_to_time(), GNUNET_TRANSPORT_TESTING_get_config_name(), GNUNET_TRANSPORT_TESTING_get_test_name(), GNUNET_TRANSPORT_TESTING_get_test_plugin_name(), GNUNET_TRANSPORT_TESTING_main_(), GNUNET_xmalloc_(), GNUNET_xmemdup_(), GNUNET_xnew_array_2d_(), GNUNET_xnew_array_3d_(), GSC_TYPEMAP_extend(), GSC_TYPEMAP_get_from_message(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_lookup_block(), handle_request_connection_reversal(), handle_revoke_message(), inflate_data(), insert_in_view(), ipv4_to_regex(), ipv6_to_regex(), kwait(), list_callback(), load_cert_from_file(), load_key_from_file(), load_plugin(), local_test_prepared_traits(), main(), maint_child_death(), make_peer(), make_serialization_file_name(), make_serialization_file_name_in_dir(), make_udp_socket(), messenger_value_to_string(), monitor_iteration_next(), my_timegm(), namecache_sqlite_lookup_block(), namestore_postgres_drop_tables(), namestore_postgres_store_records(), namestore_sqlite_store_records(), netjail_exec_traits(), nfa_closure_set_create(), nibble_to_regex(), notify_connect(), num_to_regex(), ogg_demux_and_decode(), op_get_element(), open_socket(), os_get_exec_path(), os_get_gnunet_path(), parent_control_handler(), parse_ac(), parse_name(), pass_plaintext_to_core(), PEERSTORE_hash_key(), peerstore_sqlite_delete_records(), percent_decode_keyword(), port_to_regex(), postgres_plugin_estimate_size(), postgres_plugin_put(), postgres_plugin_remove_key(), prepare_daemon(), process_acl4(), process_acl6(), process_status(), queue(), quit(), read_cb(), read_external_ipv4(), read_from_file(), receive_ready(), recursive_dns_resolution(), remove_epsilon(), repl_proc(), reply_to_dns(), resolver_lookup_get_next_label(), result_callback(), resume_client_receive(), rfn_noncontested(), run(), s2i_full(), sb_append(), sb_append_cstr(), sb_printf1(), sb_printf2(), sb_printf3(), sb_realloc(), sb_wrap(), select_del(), select_read_cb(), send_client_element(), service_client_recv(), set_external_ipv4(), setup_service(), sigchld_handler(), sockaddr_to_udpaddr_string(), sqlite_plugin_get_keys(), sqlite_plugin_put(), start_peer_traits(), start_process(), start_service_traits(), store_and_free_entries(), store_peer_presistently_iterator(), store_valid_peers(), stun_read_task(), system_create_traits(), test_service_configuration(), timeout_task_cb(), translate_dot_plus(), transmit_content(), transmit_ready(), uri_chk_parse(), uri_chk_to_string(), uri_ksk_parse(), uri_ksk_to_string(), uri_loc_to_string(), uri_sks_parse(), uri_sks_to_string(), write_data(), and write_wav_header().

◆ 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_mq_send_impl(), change_service(), 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(), do_destroy(), do_disconnect(), encrypt_fair(), env_delete_notify(), extract_array_generic(), 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_open_buffer(), GNUNET_BIO_read_open_file(), GNUNET_BIO_read_set_error(), GNUNET_BIO_read_spec_commit(), 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_open_buffer(), GNUNET_BIO_write_open_file(), GNUNET_BIO_write_spec_commit(), GNUNET_BIO_write_string(), GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_connect(), GNUNET_CADET_open_port(), GNUNET_CONFIGURATION_write(), 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_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_close(), GNUNET_DISK_file_map(), GNUNET_DISK_file_read(), GNUNET_DISK_file_read_non_blocking(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_sync(), GNUNET_DISK_file_unmap(), GNUNET_DISK_file_write(), GNUNET_DISK_file_write_blocking(), GNUNET_DISK_handle_invalid(), 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_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_meta_data(), GNUNET_HELLO_builder_from_msg(), GNUNET_HELLO_builder_get_expiration_time(), 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_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_record_set_edit_begin(), GNUNET_NAMESTORE_record_set_edit_cancel(), GNUNET_NAMESTORE_record_set_store(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_records_lookup2(), GNUNET_NAMESTORE_records_store(), 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_PEERSTORE_connect(), GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_hello_add(), GNUNET_PEERSTORE_hello_changed_notify(), GNUNET_PEERSTORE_iterate(), GNUNET_PEERSTORE_store(), 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(), 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_edit_record_set_response(), handle_estimate(), handle_generic_response(), handle_identity_result_code(), handle_identity_update(), 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_recv(), handle_response(), handle_revocation_response(), handle_revoke_ticket_result(), handle_send_ok(), handle_send_ready(), handle_statistics_end(), handle_statistics_value(), handle_statistics_watch_value(), handle_status(), handle_store_result(), 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(), nat_server_read(), neighbour_find(), notify_running(), notify_starting(), nse_cb(), op_find(), op_result(), open_port_cb(), probe_ping_task_cb(), process_job_queue(), process_queue(), process_result_message(), process_status_message(), qconv_array(), read_from_buffer(), read_from_file(), read_spec_handler_int32(), read_spec_handler_int64(), read_spec_handler_meta_data(), read_spec_handler_object(), read_spec_handler_string(), 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(), run(), schedule_action(), schedule_watch_request(), search_start(), send_get(), send_get_known_results(), send_monitor_start(), shutdown_service(), shutdown_task(), socket_set_inheritable(), socket_set_nodelay(), start_arm_service(), start_helper(), start_probe_ping_task(), stop_helper(), store_hello(), t_hmac_derive_key(), try_again(), try_anat(), try_connect(), try_reconnect(), update_memory_statistics(), watch_iterate(), write_spec_handler_int32(), write_spec_handler_int64(), write_spec_handler_meta_data(), write_spec_handler_object(), write_spec_handler_string(), 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(), check_client_join(), check_encrypted(), check_request_hello_validation(), decrypt_conclude(), deliver_message(), destroy_it(), do_send(), for_matching_monitors(), full_recursive_download(), get_action(), GNUNET_CRYPTO_eddsa_verify_(), GNUNET_CRYPTO_edx25519_verify_(), 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_meta_data(), 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_TESTING_calculate_num(), GNUNET_TIME_relative_multiply_double(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_TRANSPORT_application_validate(), GNUNET_xnew_array_2d_(), GNUNET_xnew_array_3d_(), 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(), num_to_regex(), process_peer_monitoring_cb(), publish_inspector(), put_action(), response_action(), run(), send_monitor_start(), send_to_client_iter(), shutdown_task(), start_helper(), transmit(), transmit_suggestion(), and write_spec_handler_meta_data().

◆ cfg

struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

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

Referenced by action_loop(), associate_shared_service(), connect_check_run(), create_handle(), create_internal(), database_setup(), dht_ca(), expand_dollar(), find_entry(), find_section(), get_server_addresses(), GN_request_connection_reversal(), GN_start_gnunet_nat_server_(), GNUNET_ABD_connect(), GNUNET_ARM_connect(), GNUNET_ARM_monitor_start(), GNUNET_BLOCK_context_create(), GNUNET_CADET_connect(), GNUNET_CADET_get_channel(), GNUNET_CADET_get_path(), GNUNET_CADET_list_peers(), GNUNET_CADET_list_tunnels(), GNUNET_CLIENT_connect(), GNUNET_CLIENT_test(), GNUNET_CONFIGURATION_append_value_filename(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_deserialize(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_enable_diagnostics(), GNUNET_CONFIGURATION_expand_dollar(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_get_value_choice(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_float(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_is_dirty(), GNUNET_CONFIGURATION_iterate(), GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_iterate_value_filenames(), GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_load_from(), GNUNET_CONFIGURATION_parse(), GNUNET_CONFIGURATION_parse_and_run(), GNUNET_CONFIGURATION_remove_section(), GNUNET_CONFIGURATION_remove_value_filename(), GNUNET_CONFIGURATION_serialize(), GNUNET_CONFIGURATION_serialize_diagnostics(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_CONSENSUS_create(), GNUNET_CONVERSATION_call_start(), GNUNET_CONVERSATION_phone_create(), GNUNET_CORE_connect(), GNUNET_CORE_monitor_start(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_setup_key(), GNUNET_CRYPTO_get_peer_identity(), GNUNET_CRYPTO_sign_by_peer_identity(), GNUNET_DATACACHE_create(), GNUNET_DATASTORE_connect(), GNUNET_DHT_connect(), GNUNET_DNS_connect(), GNUNET_FS_start(), GNUNET_GNS_connect(), GNUNET_IDENTITY_connect(), GNUNET_IDENTITY_ego_lookup(), GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_MESSENGER_connect(), GNUNET_MICROPHONE_create_from_hardware(), GNUNET_NAMECACHE_connect(), GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_NAT_AUTO_test_start(), GNUNET_NAT_autoconfig_start(), GNUNET_NAT_register(), GNUNET_NAT_test_start(), GNUNET_NSE_connect(), GNUNET_OS_get_suid_binary_path(), GNUNET_PEERSTORE_connect(), GNUNET_PQ_connect_with_cfg(), GNUNET_PQ_connect_with_cfg2(), GNUNET_PROGRAM_run2(), GNUNET_RECLAIM_connect(), GNUNET_REGEX_announce(), GNUNET_REGEX_search(), GNUNET_RESOLVER_connect(), GNUNET_REVOCATION_query(), GNUNET_REVOCATION_revoke(), GNUNET_RPS_connect(), GNUNET_SCALARPRODUCT_accept_computation(), GNUNET_SCALARPRODUCT_start_computation(), GNUNET_SECRETSHARING_create_session(), GNUNET_SECRETSHARING_decrypt(), GNUNET_SERVICE_main(), GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), GNUNET_SET_create(), GNUNET_SET_listen(), GNUNET_SETI_create(), GNUNET_SETI_listen(), GNUNET_SETU_create(), GNUNET_SETU_listen(), GNUNET_SOCKS_check_service(), GNUNET_SOCKS_do_connect(), GNUNET_SPEAKER_create_from_hardware(), GNUNET_SPEEDUP_start_(), GNUNET_STATISTICS_create(), GNUNET_TESTING_configuration_create(), GNUNET_TESTING_configuration_create_(), GNUNET_TESTING_peer_configure(), GNUNET_TESTING_service_run(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_communicator_connect(), GNUNET_TRANSPORT_monitor(), GNUNET_VPN_connect(), handle_auto_result(), handle_inline(), handle_uri(), init_cb(), launch_registered_services(), libgnunet_plugin_block_consensus_init(), libgnunet_plugin_block_revocation_init(), libgnunet_plugin_namecache_flat_init(), libgnunet_plugin_namecache_postgres_init(), libgnunet_plugin_namecache_sqlite_init(), libgnunet_plugin_namestore_flat_init(), libgnunet_plugin_namestore_postgres_init(), libgnunet_plugin_namestore_sqlite_init(), libgnunet_plugin_peerstore_flat_init(), libgnunet_plugin_peerstore_sqlite_init(), load_member(), load_member_session(), load_member_session_next(), load_operation(), main_task(), plugins_load(), print_filename_option(), purge_cfg_dir(), run(), save_member(), save_member_session(), save_operation(), send_create(), set_entry_hint(), shutdown_task(), sign_message_by_peer(), test_service_configuration(), testing_main(), and try_unixpath().

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

◆ timeout

◆ 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(), begin_bf_exchange(), bind_loose_channel(), callback_operation(), callback_scan_for_operations(), cancel_store_operation(), change_service(), channel_end_cb(), channel_new_cb(), check_byzantine_bounds(), check_incoming_msg(), check_intersection_p2p_bf(), check_max_differential_rounds(), 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_valid_phase(), check_vectors(), client_disconnect_cb(), client_release_ports(), collect_generation_garbage(), create_finished(), create_internal(), create_operation(), create_randomized_element_iterator(), decode_and_send(), delayed_put(), delete_finished(), destroy_operation(), determinate_avg_element_size_iterator(), dht_connect_cb(), dht_connected(), do_shutdown(), 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(), get_store_operation_type(), 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_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(), 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_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(), 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_operation(), maybe_finish(), mq_error_handler(), needs_parens(), needs_parentheses(), notify_running(), notify_starting(), ogg_demux_and_decode(), ogg_init(), op_find(), op_get_element(), op_register_element(), op_result(), packetizer(), prepare_ibf(), prepare_ibf_iterator(), process_bf(), process_header(), reconnect(), reconnect_arm_later(), remove_parentheses(), reschedule_connect(), save_operation(), 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(), start_callback(), start_operation(), stop_callback(), stop_operation(), term_callback(), union_accept(), union_channel_death(), union_evaluate(), union_op_cancel(), and use_store_operation().