GNUnet  0.11.x
gnunet-arm.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009, 2012, 2013 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
26 #include "platform.h"
27 #include "gnunet_arm_service.h"
28 #include "gnunet_constants.h"
29 #include "gnunet_util_lib.h"
30 
34 static int end;
35 
39 static int start;
40 
44 static int restart;
45 
49 static int delete;
50 
54 static int quiet;
55 
59 static int show_all;
60 
64 static int monitor;
65 
69 static int list;
70 
74 static char *init;
75 
79 static char *term;
80 
84 static char *config_file;
85 
89 static char *dir;
90 
94 static int ret;
95 
99 static struct GNUNET_ARM_Handle *h;
100 
105 
110 
114 static unsigned int phase;
115 
120 
125 
129 static int no_stdout;
130 
134 static int no_stderr;
135 
140 
144 static struct GNUNET_ARM_Operation *op;
145 
151 static void
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 }
172 
173 
180 static void
181 shutdown_task (void *cls)
182 {
183  (void) cls;
184  if (NULL != al_task)
185  {
186  GNUNET_SCHEDULER_cancel (al_task);
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  {
206  GNUNET_SCHEDULER_cancel (timeout_task);
207  timeout_task = NULL;
208  }
209  if ( (GNUNET_YES == end) &&
210  (GNUNET_YES == delete) )
211  delete_files ();
213  cfg = NULL;
214 }
215 
216 
223 static const char *
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 }
236 
237 
244 static const char *
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 }
281 
282 
288 static void
289 action_loop (void *cls);
290 
291 
301 static void
302 conn_status (void *cls,
303  int connected)
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 }
318 
319 
331 static void
332 start_callback (void *cls,
333  enum GNUNET_ARM_RequestStatus rs,
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  }
346  if ((GNUNET_ARM_RESULT_STARTING != result) &&
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 }
361 
362 
374 static void
375 stop_callback (void *cls,
376  enum GNUNET_ARM_RequestStatus rs,
378 {
379  char *msg;
380 
381  (void) cls;
382  op = NULL;
383  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
384  {
385  GNUNET_asprintf (&msg,
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  }
394  if ( (GNUNET_ARM_RESULT_STOPPING != result) &&
395  (GNUNET_ARM_RESULT_STOPPED != result) &&
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 }
417 
418 
430 static void
431 init_callback (void *cls,
432  enum GNUNET_ARM_RequestStatus rs,
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  }
446  if ((GNUNET_ARM_RESULT_STARTING != result) &&
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 }
464 
465 
477 static void
478 term_callback (void *cls,
479  enum GNUNET_ARM_RequestStatus rs,
481 {
482  char *msg;
483 
484  (void) cls;
485  op = NULL;
486  if (GNUNET_ARM_REQUEST_SENT_OK != rs)
487  {
488  GNUNET_asprintf (&msg,
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 }
518 
519 
530 static void
531 list_callback (void *cls,
532  enum GNUNET_ARM_RequestStatus rs,
533  unsigned int count,
534  const struct GNUNET_ARM_ServiceInfo *list)
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 
547  GNUNET_asprintf (&msg,
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 }
719 
720 
727 static void
728 action_loop (void *cls)
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 !=
755  GNUNET_CLIENT_test (cfg,
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 }
838 
839 
847 static void
848 srv_status (void *cls,
849  const char *service,
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 }
893 
894 
898 static void
899 timeout_task_cb (void *cls)
900 {
901  (void) cls;
902  timeout_task = NULL;
903  ret = 2;
905 }
906 
907 
916 static void
917 run (void *cls,
918  char *const *args,
919  const char *cfgfile,
920  const struct GNUNET_CONFIGURATION_Handle *c)
921 {
922  (void) cls;
923  (void) args;
924  (void) cfgfile;
925  cfg = GNUNET_CONFIGURATION_dup (c);
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)
946  m = GNUNET_ARM_monitor_start (cfg,
947  &srv_status,
948  NULL);
950  NULL);
952  NULL);
953  if (0 != timeout.rel_value_us)
954  timeout_task =
957  NULL);
958 }
959 
960 
968 int
969 main (int argc, char *const *argv)
970 {
971  struct GNUNET_GETOPT_CommandLineOption options[] = {
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 ((void *) argv);
1058  return ret;
1059  }
1060  GNUNET_free ((void *) argv);
1061  return lret;
1062 }
1063 
1064 
1065 /* end of gnunet-arm.c */
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)...
The service has previously failed, and will be restarted.
static struct GNUNET_SCHEDULER_Task * al_task
Handle for the task running the action_loop().
Definition: gnunet-arm.c:139
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
ARM stopping was initiated (there&#39;s no "stopped" for ARM itself).
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
Service stopping was initiated.
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:91
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static unsigned int phase
Processing stage that we are in.
Definition: gnunet-arm.c:114
static void timeout_task_cb(void *cls)
Task run on timeout (if -T is given).
Definition: gnunet-arm.c:899
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
uint64_t rel_value_us
The actual value.
The service was started, but then exited normally.
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
Asked to stop it, but it&#39;s already stopping.
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 int restart
Set if we are to stop/start default services (including ARM).
Definition: gnunet-arm.c:44
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, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
We disconnected from ARM, and request was not sent.
Handle for interacting with ARM.
Definition: arm_api.c:102
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
Abort an operation.
Definition: arm_api.c:794
GNUNET_ARM_Result
Replies to ARM requests.
Definition of a command line option.
Handle for interacting with ARM.
Asked to start it, but it&#39;s already started.
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
static int quiet
Set if we should not print status messages.
Definition: gnunet-arm.c:54
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
static int ret
Final status code.
Definition: gnunet-arm.c:94
void GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h)
Disconnect from the ARM service (if connected) and destroy the context.
Definition: arm_api.c:604
static char * term
Set to the name of a service to kill.
Definition: gnunet-arm.c:79
static int show_all
Set if we should print all services, including stopped ones.
Definition: gnunet-arm.c:59
The service was started, and we&#39;re currently waiting for it to be stopped.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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 _(String)
GNU gettext support macro.
Definition: platform.h:181
int main(int argc, char *const *argv)
The main function to obtain arm from gnunetd.
Definition: gnunet-arm.c:969
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static void shutdown_task(void *cls)
Main continuation-passing-style loop.
Definition: gnunet-arm.c:181
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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_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:1253
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:119
Tried to start a service, but that failed for some reason.
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
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:1039
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
Service starting was initiated.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
No standard streams should be inherited.
Definition: gnunet_os_lib.h:73
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:1280
When this flag is set, the child process will inherit stdout of the parent.
Definition: gnunet_os_lib.h:85
int GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1029
static void conn_status(void *cls, int connected)
Function called whenever we connect to or disconnect from ARM.
Definition: gnunet-arm.c:302
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:687
static int once
Global to mark if we&#39;ve run the initialization.
Definition: gnsrecord.c:68
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
uint16_t status
See PRISM_STATUS_*-constants.
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:1074
Asked to start it, but it&#39;s already starting.
static int result
Global testing status.
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:579
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...
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:892
Asked to start something, but ARM is shutting down and can&#39;t comply.
int 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.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static const char * ret_string(enum GNUNET_ARM_Result result)
Returns a string interpretation of the result.
Definition: gnunet-arm.c:245
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:930
Service was stopped.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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
Service has been started and is currently running.
Service starting was initiated.
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run on timeout.
Definition: gnunet-arm.c:124
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
Asked to stop it, but it&#39;s already stopped.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
void GNUNET_ARM_monitor_stop(struct GNUNET_ARM_MonitorHandle *h)
Disconnect from the ARM service (if connected) and destroy the context.
Message was sent successfully.
static const char * req_string(enum GNUNET_ARM_RequestStatus rs)
Returns a string interpretation of rs.
Definition: gnunet-arm.c:224
GNUNET_ARM_RequestStatus
Statuses of the requests that client can send to ARM.
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 monitor
Monitor ARM activity.
Definition: gnunet-arm.c:64
configuration data
Definition: configuration.c:85
const char * name
static int no_stderr
Do we want to give our stderr to gnunet-service-arm?
Definition: gnunet-arm.c:134
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.
static void action_loop(void *cls)
Main task that runs our various operations in order.
Definition: gnunet-arm.c:728
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
Information about a service managed by ARM.
Asked to start or stop a service, but it&#39;s not known.
int 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.
int 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, parse options).
Definition: program.c:367
GNUNET_ARM_ServiceMonitorStatus
Statuses of services.
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:331
static int no_stdout
Do we want to give our stdout to gnunet-service-arm?
Definition: gnunet-arm.c:129
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Service was stopped (never sent for ARM itself).
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966