GNUnet  0.11.x
Data Structures | Macros | Functions
arm_api.c File Reference

API for accessing the ARM service. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_arm_service.h"
#include "gnunet_protocols.h"
#include "arm.h"
Include dependency graph for arm_api.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_ARM_Operation
 Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service. More...
 
struct  GNUNET_ARM_Handle
 Handle for interacting with ARM. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "arm-api", __VA_ARGS__)
 

Functions

static int reconnect_arm (struct GNUNET_ARM_Handle *h)
 Connect to arm. More...
 
static void reconnect_arm_task (void *cls)
 Task scheduled to try to re-connect to arm. More...
 
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. More...
 
static struct GNUNET_ARM_Operationfind_op_by_id (struct GNUNET_ARM_Handle *h, uint64_t id)
 Find a control message by its unique ID. More...
 
static void handle_arm_result (void *cls, const struct GNUNET_ARM_ResultMessage *res)
 Handler for ARM replies. More...
 
static const char * pool_get (const char *pool_start, size_t pool_size, size_t str_index)
 Read from a string pool. More...
 
static int check_arm_list_result (void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
 Check that list result message is well-formed. More...
 
static void handle_arm_list_result (void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
 Handler for ARM list replies. More...
 
static void handle_confirm (void *cls, const struct GNUNET_MessageHeader *msg)
 Receive confirmation from test, ARM service is up. More...
 
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 creation of the message queue. More...
 
struct GNUNET_ARM_HandleGNUNET_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 context. More...
 
void GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h)
 Disconnect from the ARM service (if connected) and destroy the context. More...
 
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. More...
 
void GNUNET_ARM_operation_cancel (struct GNUNET_ARM_Operation *op)
 Abort an operation. More...
 
static struct GNUNET_ARM_Operationchange_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. More...
 
static void notify_running (void *cls)
 Task run to notify application that ARM is already up. More...
 
static void notify_starting (void *cls)
 Task run to notify application that ARM is being started. More...
 
struct GNUNET_ARM_OperationGNUNET_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. More...
 
struct GNUNET_ARM_OperationGNUNET_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. More...
 
struct GNUNET_ARM_OperationGNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h, GNUNET_ARM_ServiceListCallback cont, void *cont_cls)
 Request a list of running services. More...
 

Detailed Description

API for accessing the ARM service.

Author
Christian Grothoff
LRN

Definition in file arm_api.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "arm-api", __VA_ARGS__)

Function Documentation

◆ reconnect_arm()

static int reconnect_arm ( struct GNUNET_ARM_Handle h)
static

Connect to arm.

Parameters
harm handle
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 521 of file arm_api.c.

References GNUNET_ARM_Handle::cfg, GNUNET_ARM_Handle::conn_status, GNUNET_ARM_Handle::conn_status_cls, GNUNET_ARM_Handle::currently_up, env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, GNUNET_MESSAGE_TYPE_ARM_RESULT, GNUNET_MESSAGE_TYPE_ARM_TEST, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, LOG, GNUNET_ARM_Handle::mq, and mq_error_handler().

Referenced by GNUNET_ARM_connect(), GNUNET_ARM_request_service_start(), and reconnect_arm_task().

522 {
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 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
#define GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT
Response from ARM for listing currently running services.
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
#define LOG(kind,...)
Definition: arm_api.c:33
#define GNUNET_MESSAGE_TYPE_ARM_RESULT
Response from ARM.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:127
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Message handler for a specific message type.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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 '\0' terminat...
Definition: arm.h:144
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:132
#define GNUNET_MESSAGE_TYPE_ARM_TEST
Test if ARM service is online.
Reply from ARM to client.
Definition: arm.h:86
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:163
Header for all communications.
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
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reconnect_arm_task()

static void reconnect_arm_task ( void *  cls)
static

Task scheduled to try to re-connect to arm.

Parameters
clsthe struct GNUNET_ARM_Handle

Definition at line 183 of file arm_api.c.

References GNUNET_ARM_Operation::h, reconnect_arm(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by reconnect_arm_later().

184 {
185  struct GNUNET_ARM_Handle *h = cls;
186 
187  h->reconnect_task = NULL;
188  reconnect_arm (h);
189 }
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
Handle for interacting with ARM.
Definition: arm_api.c:102
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int reconnect_arm(struct GNUNET_ARM_Handle *h)
Connect to arm.
Definition: arm_api.c:521
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reconnect_arm_later()

static void reconnect_arm_later ( struct GNUNET_ARM_Handle h)
static

Close down any existing connection to the ARM service and try re-establishing it later.

Parameters
hour handle

Definition at line 199 of file arm_api.c.

References GNUNET_ARM_Handle::conn_status, GNUNET_ARM_Handle::conn_status_cls, GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_Handle::currently_up, GNUNET_ARM_operation_cancel(), GNUNET_ARM_REQUEST_DISCONNECTED, GNUNET_assert, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_ARM_Operation::list_cont, GNUNET_ARM_Handle::mq, op, GNUNET_ARM_Handle::operation_pending_head, reconnect_arm_task(), GNUNET_ARM_Handle::reconnect_task, GNUNET_ARM_Operation::result_cont, and GNUNET_ARM_Handle::retry_backoff.

Referenced by mq_error_handler().

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 }
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
We disconnected from ARM, and request was not sent.
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
void GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
Abort an operation.
Definition: arm_api.c:794
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:127
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
GNUNET_ARM_ServiceListCallback list_cont
Callback for service list requests.
Definition: arm_api.c:65
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:132
struct GNUNET_TIME_Relative retry_backoff
Current delay we use for re-trying to connect to core.
Definition: arm_api.c:152
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:163
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_op_by_id()

static struct GNUNET_ARM_Operation* find_op_by_id ( struct GNUNET_ARM_Handle h,
uint64_t  id 
)
static

Find a control message by its unique ID.

Parameters
hARM handle
idunique message ID to use for the lookup
Returns
NULL if not found

Definition at line 243 of file arm_api.c.

References GNUNET_ARM_Handle::operation_pending_head, and result.

Referenced by handle_arm_list_result(), and handle_arm_result().

245 {
247  NULL != result;
248  result = result->next)
249  if (id == result->id)
250  return result;
251  return NULL;
252 }
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
static int result
Global testing status.
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
Here is the caller graph for this function:

◆ handle_arm_result()

static void handle_arm_result ( void *  cls,
const struct GNUNET_ARM_ResultMessage res 
)
static

Handler for ARM replies.

Parameters
clsour struct GNUNET_ARM_Handle
resthe message received from the arm service

Definition at line 262 of file arm_api.c.

References GNUNET_ARM_ResultMessage::arm_msg, GNUNET_ARM_Operation::cont_cls, find_op_by_id(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_NOT_KNOWN, GNUNET_ARM_RESULT_STOPPING, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_ntohll(), GNUNET_YES, GNUNET_ARM_Operation::h, GNUNET_ARM_Operation::id, GNUNET_ARM_Operation::is_arm_stop, LOG, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, GNUNET_ARM_Message::request_id, GNUNET_ARM_ResultMessage::result, result, GNUNET_ARM_Operation::result_cont, and GNUNET_ARM_Handle::thm.

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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
ARM stopping was initiated (there's no "stopped" for ARM itself).
uint64_t request_id
ID of a request that is being replied to.
Definition: arm.h:77
#define LOG(kind,...)
Definition: arm_api.c:33
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
Handle for interacting with ARM.
Definition: arm_api.c:102
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
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.
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_ARM_Message arm_msg
Reply to client, of type is GNUNET_MESSAGE_TYPE_ARM_RESULT, with an ID.
Definition: arm.h:91
uint32_t result
Result from the enum GNUNET_ARM_Result
Definition: arm.h:96
static int result
Global testing status.
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:142
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.
Message was sent successfully.
int is_arm_stop
Is this an operation to stop the ARM service?
Definition: arm_api.c:95
Asked to start or stop a service, but it's not known.
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
#define GNUNET_YES
Definition: gnunet_common.h:77
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
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
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.
Here is the call graph for this function:

◆ pool_get()

static const char* pool_get ( const char *  pool_start,
size_t  pool_size,
size_t  str_index 
)
static

Read from a string pool.

Parameters
pool_startstart of the string pool
pool_sizesize of the string pool
str_indexindex into the string pool
Returns
an index into the string pool, or NULL if the index is out of bounds

Definition at line 325 of file arm_api.c.

References end.

Referenced by check_arm_list_result(), and handle_arm_list_result().

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 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
Here is the caller graph for this function:

◆ check_arm_list_result()

static int check_arm_list_result ( void *  cls,
const struct GNUNET_ARM_ListResultMessage lres 
)
static

Check that list result message is well-formed.

Parameters
clsour struct GNUNET_ARM_Handle
lresthe message received from the arm service
Returns
GNUNET_OK if message is well-formed

Definition at line 350 of file arm_api.c.

References GNUNET_ARM_ListResultMessage::arm_msg, GNUNET_ARM_ServiceInfoMessage::binary_index, GNUNET_ARM_ListResultMessage::count, GNUNET_break_op, GNUNET_NO, GNUNET_OK, GNUNET_ARM_Message::header, GNUNET_ARM_ServiceInfoMessage::name_index, pool_get(), and GNUNET_MessageHeader::size.

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 }
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
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
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
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_op(cond)
Use this for assertion violations caused by other peers (i.e.
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
uint16_t name_index
String pool index for the service&#39;s name.
Definition: arm.h:104
uint16_t binary_index
String pool index for the service&#39;s binary.
Definition: arm.h:109
Here is the call graph for this function:

◆ handle_arm_list_result()

static void handle_arm_list_result ( void *  cls,
const struct GNUNET_ARM_ListResultMessage lres 
)
static

Handler for ARM list replies.

Parameters
clsour struct GNUNET_ARM_Handle
lresthe message received from the arm service

Definition at line 399 of file arm_api.c.

References GNUNET_ARM_ListResultMessage::arm_msg, GNUNET_ARM_ServiceInfoMessage::binary_index, GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_ListResultMessage::count, find_op_by_id(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_REQUEST_SENT_OK, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ntohll(), GNUNET_TIME_absolute_ntoh(), GNUNET_ARM_Operation::h, GNUNET_ARM_Message::header, GNUNET_ARM_Operation::id, GNUNET_ARM_ServiceInfoMessage::last_exit_status, GNUNET_ARM_ServiceInfoMessage::last_started_at, GNUNET_ARM_Operation::list_cont, LOG, GNUNET_ARM_ServiceInfo::name, name, GNUNET_ARM_ServiceInfoMessage::name_index, op, pool_get(), GNUNET_ARM_Message::request_id, GNUNET_ARM_ServiceInfoMessage::restart_at, GNUNET_MessageHeader::size, and GNUNET_ARM_ServiceInfoMessage::status.

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 }
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
uint64_t request_id
ID of a request that is being replied to.
Definition: arm.h:77
#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_assert(cond)
Use this for fatal errors that cannot be handled.
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
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
Handle for interacting with ARM.
Definition: arm_api.c:102
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
void GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
Abort an operation.
Definition: arm_api.c:794
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
uint16_t count
Number of &#39;struct GNUNET_ARM_ServiceInfoMessage&#39; that are at the end of this message.
Definition: arm.h:156
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
GNUNET_ARM_ServiceListCallback list_cont
Callback for service list requests.
Definition: arm_api.c:65
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
const char * name
The name of the service.
uint16_t name_index
String pool index for the service&#39;s name.
Definition: arm.h:104
int16_t last_exit_status
Last process exit status.
Definition: arm.h:114
Message was sent successfully.
struct GNUNET_TIME_AbsoluteNBO last_started_at
Time when the sevice was first started, if applicable.
Definition: arm.h:135
const char * name
uint32_t status
Status from the &#39;enum GNUNET_ARM_ServiceStatus&#39;.
Definition: arm.h:124
Information about a service managed by ARM.
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
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
const char * binary
The binary used to execute the service.
struct GNUNET_TIME_AbsoluteNBO restart_at
Time when the sevice will be restarted, if applicable to the current status.
Definition: arm.h:130
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69
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
Here is the call graph for this function:

◆ handle_confirm()

static void handle_confirm ( void *  cls,
const struct GNUNET_MessageHeader msg 
)
static

Receive confirmation from test, ARM service is up.

Parameters
clsclosure with the struct GNUNET_ARM_Handle
msgmessage received

Definition at line 468 of file arm_api.c.

References GNUNET_ARM_Handle::conn_status, GNUNET_ARM_Handle::conn_status_cls, GNUNET_ARM_Handle::currently_up, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_YES, GNUNET_ARM_Operation::h, and LOG.

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 }
#define LOG(kind,...)
Definition: arm_api.c:33
Handle for interacting with ARM.
Definition: arm_api.c:102
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:127
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:132
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:163
#define GNUNET_YES
Definition: gnunet_common.h:77

◆ mq_error_handler()

static void mq_error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsclosure with the struct GNUNET_ARM_Handle *
errorerror code

Definition at line 494 of file arm_api.c.

References GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_Handle::currently_up, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_STOPPED, GNUNET_free, GNUNET_NO, GNUNET_ARM_Operation::h, op, reconnect_arm_later(), GNUNET_ARM_Operation::result_cont, and GNUNET_ARM_Handle::thm.

Referenced by reconnect_arm().

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 }
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
Handle for interacting with ARM.
Definition: arm_api.c:102
#define GNUNET_NO
Definition: gnunet_common.h:78
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:142
Message was sent successfully.
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:163
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Service was stopped (never sent for ARM itself).
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ start_arm_service()

static enum GNUNET_ARM_Result start_arm_service ( struct GNUNET_ARM_Handle h,
enum GNUNET_OS_InheritStdioFlags  std_inheritance,
struct GNUNET_DISK_FileHandle sigfd 
)
static

A client specifically requested starting of ARM itself.

Starts the ARM service.

Parameters
hthe handle with configuration details
std_inheritanceinheritance of std streams
sigfdsocket to pass to ARM for signalling
Returns
operation status code

Definition at line 654 of file arm_api.c.

References GNUNET_ARM_Handle::cfg, config, GNUNET_DISK_FileHandle::fd, GNUNET_ARM_RESULT_IS_NOT_KNOWN, GNUNET_ARM_RESULT_START_FAILED, GNUNET_ARM_RESULT_STARTING, GNUNET_asprintf(), GNUNET_CONFIGURATION_expand_dollar(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_log_config_missing(), GNUNET_NO, GNUNET_OK, GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_process_destroy(), GNUNET_OS_start_process_s(), GNUNET_strdup, and GNUNET_YES.

Referenced by GNUNET_ARM_request_service_start().

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 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
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
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_NO
Definition: gnunet_common.h:78
#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.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Tried to start a service, but that failed for some reason.
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.
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 const struct GNUNET_CONFIGURATION_Handle * config
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.
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
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 ...
#define GNUNET_YES
Definition: gnunet_common.h:77
int fd
File handle on Unix-like systems.
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".
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ change_service()

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 
)
static

Start or stop a service.

Parameters
hhandle to ARM
service_namename of the service
cbcallback to invoke when service is ready
cb_clsclosure for cb
typetype of the request
Returns
handle to queue, NULL on error

Definition at line 831 of file arm_api.c.

References GNUNET_ARM_Operation::cont_cls, env, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_htonll(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_ARM_Operation::h, GNUNET_ARM_Operation::id, GNUNET_ARM_Handle::mq, msg, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, GNUNET_ARM_Message::request_id, GNUNET_ARM_Handle::request_id_counter, GNUNET_ARM_Message::reserved, and GNUNET_ARM_Operation::result_cont.

Referenced by GNUNET_ARM_request_service_start(), and GNUNET_ARM_request_service_stop().

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 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint64_t request_id
ID of a request that is being replied to.
Definition: arm.h:77
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
uint32_t reserved
For alignment.
Definition: arm.h:70
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
#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
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:51
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
uint64_t id
Unique ID for the request.
Definition: arm_api.c:80
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
struct GNUNET_ARM_Handle * h
ARM handle.
Definition: arm_api.c:55
uint64_t request_id_counter
Counter for request identifiers.
Definition: arm_api.c:158
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
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
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
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
Here is the call graph for this function:
Here is the caller graph for this function:

◆ notify_running()

static void notify_running ( void *  cls)
static

Task run to notify application that ARM is already up.

Parameters
clsthe operation that asked ARM to be started

Definition at line 873 of file arm_api.c.

References GNUNET_ARM_Operation::async, GNUNET_ARM_Handle::conn_status, GNUNET_ARM_Handle::conn_status_cls, GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_Handle::currently_up, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_ARM_RESULT_IS_STARTED_ALREADY, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_YES, GNUNET_ARM_Operation::h, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, and GNUNET_ARM_Operation::result_cont.

Referenced by GNUNET_ARM_request_service_start().

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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
Handle for interacting with ARM.
Definition: arm_api.c:102
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.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_SCHEDULER_Task * async
Task for async completion.
Definition: arm_api.c:75
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:127
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:132
Message was sent successfully.
struct GNUNET_ARM_Handle * h
ARM handle.
Definition: arm_api.c:55
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:163
#define GNUNET_YES
Definition: gnunet_common.h:77
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
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ notify_starting()

static void notify_starting ( void *  cls)
static

Task run to notify application that ARM is being started.

Parameters
clsthe operation that asked ARM to be started

Definition at line 900 of file arm_api.c.

References GNUNET_ARM_Operation::async, GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_REQUEST_SENT_OK, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_ARM_Operation::h, LOG, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, GNUNET_ARM_Operation::result_cont, and GNUNET_ARM_Operation::starting_ret.

Referenced by GNUNET_ARM_request_service_start().

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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define LOG(kind,...)
Definition: arm_api.c:33
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
Handle for interacting with ARM.
Definition: arm_api.c:102
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:70
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_SCHEDULER_Task * async
Task for async completion.
Definition: arm_api.c:75
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:117
Message was sent successfully.
struct GNUNET_ARM_Handle * h
ARM handle.
Definition: arm_api.c:55
enum GNUNET_ARM_Result starting_ret
Result of this operation for notify_starting().
Definition: arm_api.c:85
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
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:60
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function: