GNUnet  0.11.x
arm_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009, 2010, 2012, 2013, 2016, 2019 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 
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_arm_service.h"
30 #include "gnunet_protocols.h"
31 #include "arm.h"
32 
33 #define LOG(kind, ...) GNUNET_log_from (kind, "arm-api", __VA_ARGS__)
34 
35 
41 {
46 
51 
56 
61 
66 
70  void *cont_cls;
71 
76 
80  uint64_t id;
81 
86 
91 
96 };
97 
98 
103 {
108 
113 
118 
123 
128 
133 
143 
148 
152  struct GNUNET_TIME_Relative retry_backoff;
153 
159 
164 };
165 
166 
173 static int
175 
176 
182 static void
184 {
185  struct GNUNET_ARM_Handle *h = cls;
186 
187  h->reconnect_task = NULL;
188  reconnect_arm (h);
189 }
190 
191 
198 static void
200 {
201  struct GNUNET_ARM_Operation *op;
202 
203  if (NULL != h->mq)
204  {
205  GNUNET_MQ_destroy (h->mq);
206  h->mq = NULL;
207  }
208  h->currently_up = GNUNET_NO;
209  GNUNET_assert (NULL == h->reconnect_task);
210  h->reconnect_task =
213  h);
214  while (NULL != (op = h->operation_pending_head))
215  {
216  if (NULL != op->result_cont)
217  op->result_cont (op->cont_cls,
219  0);
220  if (NULL != op->list_cont)
221  op->list_cont (op->cont_cls,
223  0,
224  NULL);
226  }
229  if (NULL != h->conn_status)
231  GNUNET_NO);
232 }
233 
234 
242 static struct GNUNET_ARM_Operation *
244  uint64_t id)
245 {
247  NULL != result;
248  result = result->next)
249  if (id == result->id)
250  return result;
251  return NULL;
252 }
253 
254 
261 static void
262 handle_arm_result (void *cls,
263  const struct GNUNET_ARM_ResultMessage *res)
264 {
265  struct GNUNET_ARM_Handle *h = cls;
266  struct GNUNET_ARM_Operation *op;
267  uint64_t id;
270  void *result_cont_cls;
271 
272  id = GNUNET_ntohll (res->arm_msg.request_id);
273  op = find_op_by_id (h,
274  id);
275  if (NULL == op)
276  {
278  "Message with unknown id %llu\n",
279  (unsigned long long) id);
280  return;
281  }
282 
283  result = (enum GNUNET_ARM_Result) ntohl (res->result);
284  if ( (GNUNET_YES == op->is_arm_stop) &&
286  {
287  /* special case: if we are stopping 'gnunet-service-arm', we do not just
288  wait for the result message, but also wait for the service to close
289  the connection (and then we have to close our client handle as well);
290  this is done by installing a different receive handler, waiting for
291  the connection to go down */if (NULL != h->thm)
292  {
293  GNUNET_break (0);
294  op->result_cont (h->thm->cont_cls,
297  GNUNET_free (h->thm);
298  }
301  op);
302  h->thm = op;
303  return;
304  }
305  result_cont = op->result_cont;
306  result_cont_cls = op->cont_cls;
308  if (NULL != result_cont)
309  result_cont (result_cont_cls,
311  result);
312 }
313 
314 
324 static const char *
325 pool_get (const char *pool_start,
326  size_t pool_size,
327  size_t str_index)
328 {
329  const char *str_start;
330  const char *end;
331 
332  if (str_index >= pool_size)
333  return NULL;
334  str_start = pool_start + str_index;
335  end = memchr (str_start, 0, pool_size - str_index);
336  if (NULL == end)
337  return NULL;
338  return str_start;
339 }
340 
341 
349 static int
351  const struct GNUNET_ARM_ListResultMessage *lres)
352 {
353  uint16_t rcount = ntohs (lres->count);
354  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres);
355  struct GNUNET_ARM_ServiceInfoMessage *ssm;
356  size_t pool_size;
357  char *pool_start;
358 
359  (void) cls;
360  if ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) > msize))
361  {
362  GNUNET_break_op (0);
363  return GNUNET_NO;
364  }
365  ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1];
366  pool_start = (char *) (ssm + rcount);
367  pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage));
368  for (unsigned int i = 0; i < rcount; i++)
369  {
370  uint16_t name_index = ntohs (ssm->name_index);
371  uint16_t binary_index = ntohs (ssm->binary_index);
372  if (NULL == pool_get (pool_start,
373  pool_size,
374  name_index))
375  {
376  GNUNET_break_op (0);
377  return GNUNET_NO;
378  }
379  if (NULL == pool_get (pool_start,
380  pool_size,
381  binary_index))
382  {
383  GNUNET_break_op (0);
384  return GNUNET_NO;
385  }
386  ssm++;
387  }
388  return GNUNET_OK;
389 }
390 
391 
398 static void
400  const struct GNUNET_ARM_ListResultMessage *lres)
401 {
402  struct GNUNET_ARM_Handle *h = cls;
403  uint16_t rcount = ntohs (lres->count);
404  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres);
405  struct GNUNET_ARM_ServiceInfo list[rcount];
406  struct GNUNET_ARM_ServiceInfoMessage *ssm;
407  struct GNUNET_ARM_Operation *op;
408  uint64_t id;
409  size_t pool_size;
410  char *pool_start;
411 
412  id = GNUNET_ntohll (lres->arm_msg.request_id);
413  op = find_op_by_id (h, id);
414  if (NULL == op)
415  {
417  "Message with unknown id %llu\n",
418  (unsigned long long) id);
419  return;
420  }
421 
422  GNUNET_assert ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) <=
423  msize));
424 
425  ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1];
426  pool_start = (char *) (ssm + rcount);
427  pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage));
428 
429  for (unsigned int i = 0; i < rcount; i++)
430  {
431  uint16_t name_index = ntohs (ssm->name_index);
432  uint16_t binary_index = ntohs (ssm->binary_index);
433  const char *name;
434  const char *binary;
435 
436  GNUNET_assert (NULL != (name = pool_get (pool_start,
437  pool_size,
438  name_index)));
439  GNUNET_assert (NULL != (binary = pool_get (pool_start,
440  pool_size,
441  binary_index)));
442  list[i] = (struct GNUNET_ARM_ServiceInfo) {
443  .name = name,
444  .binary = binary,
445  .status = ntohl (ssm->status),
446  .last_started_at = GNUNET_TIME_absolute_ntoh (ssm->last_started_at),
447  .restart_at = GNUNET_TIME_absolute_ntoh (ssm->restart_at),
448  .last_exit_status = ntohs (ssm->last_exit_status),
449  };
450  ssm++;
451  }
452  if (NULL != op->list_cont)
453  op->list_cont (op->cont_cls,
455  rcount,
456  list);
458 }
459 
460 
467 static void
468 handle_confirm (void *cls,
469  const struct GNUNET_MessageHeader *msg)
470 {
471  struct GNUNET_ARM_Handle *h = cls;
472 
473  (void) msg;
475  "Got confirmation from ARM that we are up!\n");
476  if (GNUNET_NO == h->currently_up)
477  {
479  if (NULL != h->conn_status)
481  }
482 }
483 
484 
493 static void
494 mq_error_handler (void *cls,
495  enum GNUNET_MQ_Error error)
496 {
497  struct GNUNET_ARM_Handle *h = cls;
498  struct GNUNET_ARM_Operation *op;
499 
500  (void) error;
501  h->currently_up = GNUNET_NO;
502  if (NULL != (op = h->thm))
503  {
504  h->thm = NULL;
505  op->result_cont (op->cont_cls,
508  GNUNET_free (op);
509  }
511 }
512 
513 
520 static int
522 {
523  struct GNUNET_MQ_MessageHandler handlers[] = {
524  GNUNET_MQ_hd_fixed_size (arm_result,
527  h),
528  GNUNET_MQ_hd_var_size (arm_list_result,
531  h),
532  GNUNET_MQ_hd_fixed_size (confirm,
534  struct GNUNET_MessageHeader,
535  h),
537  };
538  struct GNUNET_MessageHeader *test;
539  struct GNUNET_MQ_Envelope *env;
540 
541  if (NULL != h->mq)
542  return GNUNET_OK;
544  h->mq = GNUNET_CLIENT_connect (h->cfg,
545  "arm",
546  handlers,
548  h);
549  if (NULL == h->mq)
550  {
552  "GNUNET_CLIENT_connect returned NULL\n");
553  if (NULL != h->conn_status)
555  GNUNET_SYSERR);
556  return GNUNET_SYSERR;
557  }
559  "Sending TEST message to ARM\n");
560  env = GNUNET_MQ_msg (test,
562  GNUNET_MQ_send (h->mq, env);
563  return GNUNET_OK;
564 }
565 
566 
578 struct GNUNET_ARM_Handle *
581  void *conn_status_cls)
582 {
583  struct GNUNET_ARM_Handle *h;
584 
585  h = GNUNET_new (struct GNUNET_ARM_Handle);
586  h->cfg = cfg;
589  if (GNUNET_OK != reconnect_arm (h))
590  {
591  GNUNET_free (h);
592  return NULL;
593  }
594  return h;
595 }
596 
597 
603 void
605 {
606  struct GNUNET_ARM_Operation *op;
607 
608  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
609  while (NULL != (op = h->operation_pending_head))
610  {
613  op);
614  if (NULL != op->result_cont)
615  op->result_cont (op->cont_cls,
617  0);
618  if (NULL != op->list_cont)
619  op->list_cont (op->cont_cls,
621  0,
622  NULL);
623  if (NULL != op->async)
624  {
626  op->async = NULL;
627  }
628  GNUNET_free (op);
629  }
630  if (NULL != h->mq)
631  {
632  GNUNET_MQ_destroy (h->mq);
633  h->mq = NULL;
634  }
635  if (NULL != h->reconnect_task)
636  {
638  h->reconnect_task = NULL;
639  }
640  GNUNET_free (h);
641 }
642 
643 
653 static enum GNUNET_ARM_Result
655  enum GNUNET_OS_InheritStdioFlags std_inheritance,
656  struct GNUNET_DISK_FileHandle *sigfd)
657 {
658  struct GNUNET_OS_Process *proc;
659  char *cbinary;
660  char *binary;
661  char *quotedbinary;
662  char *config;
663  char *loprefix;
664  char *lopostfix;
665  int ld[2];
666  int *lsocks;
667 
668  if (NULL == sigfd)
669  {
670  lsocks = NULL;
671  }
672  else
673  {
674  ld[0] = sigfd->fd;
675  ld[1] = -1;
676  lsocks = ld;
677  }
679  "arm",
680  "PREFIX",
681  &loprefix))
682  loprefix = GNUNET_strdup ("");
683  else
684  loprefix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, loprefix);
686  "arm",
687  "OPTIONS",
688  &lopostfix))
689  lopostfix = GNUNET_strdup ("");
690  else
691  lopostfix = GNUNET_CONFIGURATION_expand_dollar (h->cfg,
692  lopostfix);
693  if (GNUNET_OK !=
695  "arm",
696  "BINARY",
697  &cbinary))
698  {
700  "arm",
701  "BINARY");
702  GNUNET_free (loprefix);
703  GNUNET_free (lopostfix);
705  }
707  "arm",
708  "CONFIG",
709  &config))
710  config = NULL;
711  binary = GNUNET_OS_get_libexec_binary_path (cbinary);
712  GNUNET_asprintf (&quotedbinary,
713  "\"%s\"",
714  binary);
715  GNUNET_free (cbinary);
716  if ( (GNUNET_YES ==
718  "TESTING",
719  "WEAKRANDOM")) &&
720  (GNUNET_YES ==
722  "TESTING",
723  "WEAKRANDOM")) &&
724  (GNUNET_NO ==
726  "TESTING",
727  "HOSTFILE")) )
728  {
729  /* Means we are ONLY running locally */
730  /* we're clearly running a test, don't daemonize */
731  if (NULL == config)
733  std_inheritance,
734  lsocks,
735  loprefix,
736  quotedbinary,
737  /* no daemonization! */
738  lopostfix,
739  NULL);
740  else
742  std_inheritance,
743  lsocks,
744  loprefix,
745  quotedbinary,
746  "-c",
747  config,
748  /* no daemonization! */
749  lopostfix,
750  NULL);
751  }
752  else
753  {
754  if (NULL == config)
756  std_inheritance,
757  lsocks,
758  loprefix,
759  quotedbinary,
760  "-d", /* do daemonize */
761  lopostfix,
762  NULL);
763  else
765  std_inheritance,
766  lsocks,
767  loprefix,
768  quotedbinary,
769  "-c",
770  config,
771  "-d", /* do daemonize */
772  lopostfix,
773  NULL);
774  }
775  GNUNET_free (binary);
776  GNUNET_free (quotedbinary);
777  GNUNET_free_non_null (config);
778  GNUNET_free (loprefix);
779  GNUNET_free (lopostfix);
780  if (NULL == proc)
784 }
785 
786 
793 void
795 {
796  struct GNUNET_ARM_Handle *h = op->h;
797 
798  if (NULL != op->async)
799  {
801  op->async = NULL;
802  }
803  if (NULL != op->rfd)
804  {
806  op->rfd = NULL;
807  }
808  if (h->thm == op)
809  {
810  op->result_cont = NULL;
811  return;
812  }
815  op);
816  GNUNET_free (op);
817 }
818 
819 
830 static struct GNUNET_ARM_Operation *
832  const char *service_name,
834  void *cb_cls,
835  uint16_t type)
836 {
837  struct GNUNET_ARM_Operation *op;
838  size_t slen;
839  struct GNUNET_MQ_Envelope *env;
840  struct GNUNET_ARM_Message *msg;
841 
842  slen = strlen (service_name) + 1;
843  if (slen + sizeof(struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE)
844  {
845  GNUNET_break (0);
846  return NULL;
847  }
848  if (0 == h->request_id_counter)
849  h->request_id_counter++;
850  op = GNUNET_new (struct GNUNET_ARM_Operation);
851  op->h = h;
852  op->result_cont = cb;
853  op->cont_cls = cb_cls;
854  op->id = h->request_id_counter++;
857  op);
858  env = GNUNET_MQ_msg_extra (msg, slen, type);
859  msg->reserved = htonl (0);
860  msg->request_id = GNUNET_htonll (op->id);
861  GNUNET_memcpy (&msg[1], service_name, slen);
862  GNUNET_MQ_send (h->mq, env);
863  return op;
864 }
865 
866 
872 static void
873 notify_running (void *cls)
874 {
875  struct GNUNET_ARM_Operation *op = cls;
876  struct GNUNET_ARM_Handle *h = op->h;
877 
878  op->async = NULL;
881  op);
882  if (NULL != op->result_cont)
883  op->result_cont (op->cont_cls,
886  if ( (GNUNET_YES == h->currently_up) &&
887  (NULL != h->conn_status) )
889  GNUNET_YES);
890  GNUNET_free (op);
891 }
892 
893 
899 static void
900 notify_starting (void *cls)
901 {
902  struct GNUNET_ARM_Operation *op = cls;
903  struct GNUNET_ARM_Handle *h = op->h;
904 
905  op->async = NULL;
907  "Notifying client that we started the ARM service\n");
910  op);
911  if (NULL != op->result_cont)
912  op->result_cont (op->cont_cls,
914  op->starting_ret);
915  GNUNET_free (op);
916 }
917 
918 
929 struct GNUNET_ARM_Operation *
931  const char *service_name,
933  std_inheritance,
935  void *cont_cls)
936 {
937  struct GNUNET_ARM_Operation *op;
938  enum GNUNET_ARM_Result ret;
939  struct GNUNET_DISK_PipeHandle *sig;
940  struct GNUNET_DISK_FileHandle *wsig;
941 
943  "Starting service `%s'\n",
944  service_name);
945  if (0 != strcasecmp ("arm",
946  service_name))
947  return change_service (h,
948  service_name,
949  cont,
950  cont_cls,
952 
953  /* Possible cases:
954  * 1) We're connected to ARM already. Invoke the callback immediately.
955  * 2) We're not connected to ARM.
956  * Cancel any reconnection attempts temporarily, then perform
957  * a service test.
958  */if (GNUNET_YES == h->currently_up)
959  {
961  "ARM is already running\n");
962  op = GNUNET_new (struct GNUNET_ARM_Operation);
963  op->h = h;
964  op->result_cont = cont;
965  op->cont_cls = cont_cls;
968  op);
970  return op;
971  }
972  /* This is an inherently uncertain choice, as it is of course
973  theoretically possible that ARM is up and we just did not
974  yet complete the MQ handshake. However, given that users
975  are unlikely to hammer 'gnunet-arm -s' on a busy system,
976  the above check should catch 99.99% of the cases where ARM
977  is already running. */LOG (GNUNET_ERROR_TYPE_DEBUG,
978  "Starting ARM service\n");
979  if (NULL == (sig = GNUNET_DISK_pipe (GNUNET_NO,
980  GNUNET_NO,
981  GNUNET_NO,
982  GNUNET_YES)))
983  {
985  "pipe");
986  }
987  wsig = GNUNET_DISK_pipe_detach_end (sig,
989  ret = start_arm_service (h,
990  std_inheritance,
991  wsig);
992  GNUNET_DISK_file_close (wsig);
993  if (GNUNET_ARM_RESULT_STARTING == ret)
994  reconnect_arm (h);
995  op = GNUNET_new (struct GNUNET_ARM_Operation);
996  op->h = h;
997  op->result_cont = cont;
998  op->cont_cls = cont_cls;
1001  op);
1002  op->starting_ret = ret;
1003  if (NULL != sig)
1004  {
1005  op->rfd = GNUNET_DISK_pipe_detach_end (sig,
1007  /* Wait at most a minute for gnunet-service-arm to be up, as beyond
1008  that something clearly just went wrong */
1010  op->rfd,
1011  &notify_starting,
1012  op);
1013  }
1014  else
1015  {
1017  op);
1018  }
1019  GNUNET_DISK_pipe_close (sig);
1020  return op;
1021 }
1022 
1023 
1038 struct GNUNET_ARM_Operation *
1040  const char *service_name,
1042  void *cont_cls)
1043 {
1044  struct GNUNET_ARM_Operation *op;
1045 
1047  "Stopping service `%s'\n",
1048  service_name);
1049  op = change_service (h,
1050  service_name,
1051  cont,
1052  cont_cls,
1054  if (NULL == op)
1055  return NULL;
1056  /* If the service is ARM, set a flag as we will use MQ errors
1057  to detect that the process is really gone. */
1058  if (0 == strcasecmp (service_name,
1059  "arm"))
1060  op->is_arm_stop = GNUNET_YES;
1061  return op;
1062 }
1063 
1064 
1073 struct GNUNET_ARM_Operation *
1076  void *cont_cls)
1077 {
1078  struct GNUNET_ARM_Operation *op;
1079  struct GNUNET_MQ_Envelope *env;
1080  struct GNUNET_ARM_Message *msg;
1081 
1083  "Requesting LIST from ARM service\n");
1084  if (0 == h->request_id_counter)
1085  h->request_id_counter++;
1086  op = GNUNET_new (struct GNUNET_ARM_Operation);
1087  op->h = h;
1088  op->list_cont = cont;
1089  op->cont_cls = cont_cls;
1090  op->id = h->request_id_counter++;
1093  op);
1094  env = GNUNET_MQ_msg (msg,
1096  msg->reserved = htonl (0);
1097  msg->request_id = GNUNET_htonll (op->id);
1098  GNUNET_MQ_send (h->mq, env);
1099  return op;
1100 }
1101 
1102 
1103 /* end of arm_api.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
void(* GNUNET_ARM_ServiceListCallback)(void *cls, enum GNUNET_ARM_RequestStatus rs, unsigned int count, const struct GNUNET_ARM_ServiceInfo *list)
Callback function invoked when list operation is complete.
static void notify_starting(void *cls)
Task run to notify application that ARM is being started.
Definition: arm_api.c:900
struct GNUNET_ARM_Operation * next
This is a doubly-linked list.
Definition: arm_api.c:45
GNUNET_OS_InheritStdioFlags
Flags that determine which of the standard streams should be inherited by the child process...
Definition: gnunet_os_lib.h:68
ARM stopping was initiated (there&#39;s no "stopped" for ARM itself).
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1345
#define GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT
Response from ARM for listing currently running services.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
uint64_t request_id
ID of a request that is being replied to.
Definition: arm.h:77
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1057
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:287
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
GNUNET_MQ_Error
Error codes for the queue.
#define GNUNET_TIME_UNIT_MINUTES
One minute.
#define LOG(kind,...)
Definition: arm_api.c:33
static const char * pool_get(const char *pool_start, size_t pool_size, size_t str_index)
Read from a string pool.
Definition: arm_api.c:325
#define GNUNET_MESSAGE_TYPE_ARM_RESULT
Response from ARM.
char * GNUNET_CONFIGURATION_expand_dollar(const struct GNUNET_CONFIGURATION_Handle *cfg, char *orig)
Expand an expression of the form "$FOO/BAR" to "DIRECTORY/BAR" where either in the "PATHS" section or...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int check_arm_list_result(void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
Check that list result message is well-formed.
Definition: arm_api.c:350
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
#define GNUNET_MESSAGE_TYPE_ARM_START
Request to ARM to start a service.
#define GNUNET_MESSAGE_TYPE_ARM_STOP
Request to ARM to stop a service.
struct GNUNET_ARM_Message arm_msg
Reply to client, of type is GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, with an ID.
Definition: arm.h:150
We disconnected from ARM, and request was not sent.
static void handle_confirm(void *cls, const struct GNUNET_MessageHeader *msg)
Receive confirmation from test, ARM service is up.
Definition: arm_api.c:468
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
Handle for interacting with ARM.
Definition: arm_api.c:102
static void reconnect_arm_task(void *cls)
Task scheduled to try to re-connect to arm.
Definition: arm_api.c:183
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1636
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
void GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
Abort an operation.
Definition: arm_api.c:794
#define GNUNET_new(type)
Allocate a struct or union of the given type.
GNUNET_ARM_Result
Replies to ARM requests.
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
Asked to start it, but it&#39;s already started.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
uint32_t reserved
For alignment.
Definition: arm.h:70
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
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_DISK_FileHandle * rfd
File descriptor to close on operation stop, if not NULL.
Definition: arm_api.c:90
uint16_t count
Number of &#39;struct GNUNET_ARM_ServiceInfoMessage&#39; that are at the end of this message.
Definition: arm.h:156
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SCHEDULER_Task * async
Task for async completion.
Definition: arm_api.c:75
static void notify_running(void *cls)
Task run to notify application that ARM is already up.
Definition: arm_api.c:873
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:127
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static enum GNUNET_ARM_Result start_arm_service(struct GNUNET_ARM_Handle *h, enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_FileHandle *sigfd)
A client specifically requested starting of ARM itself.
Definition: arm_api.c:654
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
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
struct GNUNET_ARM_Message arm_msg
Reply to client, of type is GNUNET_MESSAGE_TYPE_ARM_RESULT, with an ID.
Definition: arm.h:91
Tried to start a service, but that failed for some reason.
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.
uint32_t result
Result from the enum GNUNET_ARM_Result
Definition: arm.h:96
struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Detaches one of the ends from the pipe.
Definition: disk.c:1682
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
static struct GNUNET_ARM_Operation * change_service(struct GNUNET_ARM_Handle *h, const char *service_name, GNUNET_ARM_ResultCallback cb, void *cb_cls, uint16_t type)
Start or stop a service.
Definition: arm_api.c:831
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
static void conn_status(void *cls, int connected)
Function called whenever we connect to or disconnect from ARM.
Definition: gnunet-arm.c:302
GNUNET_ARM_ServiceListCallback list_cont
Callback for service list requests.
Definition: arm_api.c:65
int GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:51
static const struct GNUNET_CONFIGURATION_Handle * config
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
struct GNUNET_MessageHeader header
Reply to client, type is GNUNET_MESSAGE_TYPE_ARM_RESULT or GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT.
Definition: arm.h:65
static int result
Global testing status.
The writing-end of a pipe.
static void reconnect_arm_later(struct GNUNET_ARM_Handle *h)
Close down any existing connection to the ARM service and try re-establishing it later.
Definition: arm_api.c:199
The reading-end of a pipe.
void(* GNUNET_ARM_ConnectionStatusCallback)(void *cls, int connected)
Function called whenever we connect to or disconnect from ARM.
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
const char * name
The name of the service.
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
static void handle_arm_result(void *cls, const struct GNUNET_ARM_ResultMessage *res)
Handler for ARM replies.
Definition: arm_api.c:262
Message handler for a specific message type.
static int res
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:142
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(int blocking_read, int blocking_write, int inherit_read, int inherit_write)
Creates an interprocess channel.
Definition: disk.c:1526
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.
void(* GNUNET_ARM_ResultCallback)(void *cls, enum GNUNET_ARM_RequestStatus rs, enum GNUNET_ARM_Result result)
Function called in response to a start/stop request.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
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
uint16_t name_index
String pool index for the service&#39;s name.
Definition: arm.h:104
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_MESSAGE_TYPE_ARM_LIST
Request to ARM to list all currently running services.
int16_t last_exit_status
Last process exit status.
Definition: arm.h:114
uint64_t id
Unique ID for the request.
Definition: arm_api.c:80
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Reply from ARM to client for the GNUNET_MESSAGE_TYPE_ARM_LIST request followed by count &#39;\0&#39; terminat...
Definition: arm.h:144
struct GNUNET_ARM_Operation * prev
This is a doubly-linked list.
Definition: arm_api.c:50
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:132
Message was sent successfully.
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_ARM_Handle * h
ARM handle.
Definition: arm_api.c:55
int GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1715
uint64_t request_id_counter
Counter for request identifiers.
Definition: arm_api.c:158
#define GNUNET_MESSAGE_TYPE_ARM_TEST
Test if ARM service is online.
struct GNUNET_TIME_Relative retry_backoff
Current delay we use for re-trying to connect to core.
Definition: arm_api.c:152
Reply from ARM to client.
Definition: arm.h:86
struct GNUNET_TIME_AbsoluteNBO last_started_at
Time when the sevice was first started, if applicable.
Definition: arm.h:135
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:163
configuration data
Definition: configuration.c:85
const char * name
enum GNUNET_ARM_Result starting_ret
Result of this operation for notify_starting().
Definition: arm_api.c:85
struct GNUNET_OS_Process * GNUNET_OS_start_process_s(int pipe_control, unsigned int std_inheritance, const int *lsocks, const char *filename,...)
Start a process.
Definition: os_priority.c:762
int is_arm_stop
Is this an operation to stop the ARM service?
Definition: arm_api.c:95
Entry in list of pending tasks.
Definition: scheduler.c:134
uint32_t status
Status from the &#39;enum GNUNET_ARM_ServiceStatus&#39;.
Definition: arm.h:124
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.
char * GNUNET_OS_get_libexec_binary_path(const char *progname)
Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the ...
static struct GNUNET_ARM_Operation * find_op_by_id(struct GNUNET_ARM_Handle *h, uint64_t id)
Find a control message by its unique ID.
Definition: arm_api.c:243
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Header for all communications.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_YES
Definition: gnunet_common.h:77
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
int fd
File handle on Unix-like systems.
struct GNUNET_ARM_Operation * operation_pending_tail
Tail of doubly-linked list of pending operations.
Definition: arm_api.c:122
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static int reconnect_arm(struct GNUNET_ARM_Handle *h)
Connect to arm.
Definition: arm_api.c:521
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
Service was stopped (never sent for ARM itself).
static void handle_arm_list_result(void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
Handler for ARM list replies.
Definition: arm_api.c:399
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
Handle used to access files (and pipes).
Handle used to manage a pipe.
Definition: disk.c:68
struct GNUNET_TIME_AbsoluteNBO restart_at
Time when the sevice will be restarted, if applicable to the current status.
Definition: arm.h:130
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
uint16_t binary_index
String pool index for the service&#39;s binary.
Definition: arm.h:109
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: arm_api.c:494