GNUnet  0.10.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 int check_arm_list_result (void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
 Checked 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)
 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__)

Definition at line 33 of file arm_api.c.

Referenced by check_access(), client_disconnect_cb(), client_message_tokenizer_callback(), connect_error(), connect_fail_continuation(), connect_success_continuation(), create_macendpoint(), create_session(), detach_terminal(), GNUNET_ARM_disconnect(), GNUNET_ARM_request_service_list(), GNUNET_ARM_request_service_start(), GNUNET_ARM_request_service_stop(), GNUNET_CONNECTION_connect_socket(), GNUNET_CONNECTION_create_from_accept(), GNUNET_CONNECTION_destroy(), GNUNET_CONNECTION_notify_transmit_ready(), GNUNET_SERVER_client_disconnect(), GNUNET_SERVER_destroy(), GNUNET_SERVER_inject(), GNUNET_SERVER_mst_receive(), GNUNET_SERVER_receive_done(), GNUNET_SERVER_stop_listening(), GST_forwarded_operation_timeout(), GST_queue_host_registration(), handle_arm_list_result(), handle_arm_result(), handle_confirm(), handle_helper_message(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), hr_completion(), LEGACY_SERVICE_get_server_addresses(), LEGACY_SERVICE_run(), LIBGNUNET_PLUGIN_TRANSPORT_INIT(), notify_starting(), open_listen_socket(), parse_shared_services(), process_acl4(), process_acl6(), process_data(), process_incoming(), process_listen_socket(), process_mst(), process_notify(), receive_ready(), reconnect_arm(), register_next_host(), restart_processing(), send_ack(), send_hello_beacon(), service_task(), set_user_id(), setup_service(), signal_receive_error(), signal_receive_timeout(), signal_transmit_error(), transmit_fragment(), transmit_ready(), transmit_timeout(), try_connect_using_address(), warn_no_receive_done(), wlan_plugin_address_suggested(), wlan_plugin_get_session(), and wlan_plugin_send().

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 431 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().

432 {
434  { GNUNET_MQ_hd_fixed_size(arm_result,
437  h),
438  GNUNET_MQ_hd_var_size(arm_list_result,
441  h),
442  GNUNET_MQ_hd_fixed_size(confirm,
444  struct GNUNET_MessageHeader,
445  h),
447  struct GNUNET_MessageHeader *test;
448  struct GNUNET_MQ_Envelope *env;
449 
450  if (NULL != h->mq)
451  return GNUNET_OK;
453  h->mq = GNUNET_CLIENT_connect(h->cfg, "arm", handlers, &mq_error_handler, h);
454  if (NULL == h->mq)
455  {
456  LOG(GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CLIENT_connect returned NULL\n");
457  if (NULL != h->conn_status)
459  return GNUNET_SYSERR;
460  }
461  LOG(GNUNET_ERROR_TYPE_DEBUG, "Sending TEST message to ARM\n");
463  GNUNET_MQ_send(h->mq, env);
464  return GNUNET_OK;
465 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:105
#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:900
#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:100
#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:120
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:102
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:125
#define GNUNET_MESSAGE_TYPE_ARM_TEST
Test if ARM service is online.
Reply from ARM to client.
Definition: arm.h:84
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:156
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:351
#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:405
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 176 of file arm_api.c.

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

Referenced by reconnect_arm_later().

177 {
178  struct GNUNET_ARM_Handle *h = cls;
179 
180  h->reconnect_task = NULL;
181  reconnect_arm(h);
182 }
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:140
Handle for interacting with ARM.
Definition: arm_api.c:96
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
static int reconnect_arm(struct GNUNET_ARM_Handle *h)
Connect to arm.
Definition: arm_api.c:431
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 192 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().

193 {
194  struct GNUNET_ARM_Operation *op;
195 
196  if (NULL != h->mq)
197  {
198  GNUNET_MQ_destroy(h->mq);
199  h->mq = NULL;
200  }
201  h->currently_up = GNUNET_NO;
202  GNUNET_assert(NULL == h->reconnect_task);
203  h->reconnect_task =
205  while (NULL != (op = h->operation_pending_head))
206  {
207  if (NULL != op->result_cont)
209  if (NULL != op->list_cont)
212  }
215  if (NULL != h->conn_status)
217 }
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:140
#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:176
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:100
#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:663
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:69
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:120
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:1237
GNUNET_ARM_ServiceListCallback list_cont
Callback for service list requests.
Definition: arm_api.c:64
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:110
#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:125
struct GNUNET_TIME_Relative retry_backoff
Current delay we use for re-trying to connect to core.
Definition: arm_api.c:145
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:156
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:59
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 228 of file arm_api.c.

References GNUNET_ARM_Operation::id, GNUNET_ARM_Operation::next, GNUNET_ARM_Handle::operation_pending_head, and result.

Referenced by handle_arm_list_result(), and handle_arm_result().

229 {
231 
232  for (result = h->operation_pending_head; NULL != result;
233  result = result->next)
234  if (id == result->id)
235  return result;
236  return NULL;
237 }
struct GNUNET_ARM_Operation * next
This is a doubly-linked list.
Definition: arm_api.c:44
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:110
uint64_t id
Unique ID for the request.
Definition: arm_api.c:79
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 247 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.

248 {
249  struct GNUNET_ARM_Handle *h = cls;
250  struct GNUNET_ARM_Operation *op;
251  uint64_t id;
254  void *result_cont_cls;
255 
256  id = GNUNET_ntohll(res->arm_msg.request_id);
257  op = find_op_by_id(h, id);
258  if (NULL == op)
259  {
261  "Message with unknown id %llu\n",
262  (unsigned long long)id);
263  return;
264  }
265 
266  result = (enum GNUNET_ARM_Result)ntohl(res->result);
268  {
269  /* special case: if we are stopping 'gnunet-service-arm', we do not just
270  wait for the result message, but also wait for the service to close
271  the connection (and then we have to close our client handle as well);
272  this is done by installing a different receive handler, waiting for
273  the connection to go down */
274  if (NULL != h->thm)
275  {
276  GNUNET_break(0);
277  op->result_cont(h->thm->cont_cls,
280  GNUNET_free(h->thm);
281  }
284  op);
285  h->thm = op;
286  return;
287  }
288  result_cont = op->result_cont;
289  result_cont_cls = op->cont_cls;
291  if (NULL != result_cont)
292  result_cont(result_cont_cls, GNUNET_ARM_REQUEST_SENT_OK, result);
293 }
#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:75
#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:96
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:663
GNUNET_ARM_Result
Replies to ARM requests.
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:69
#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:94
struct GNUNET_ARM_Message arm_msg
Reply to client, of type is GNUNET_MESSAGE_TYPE_ARM_RESULT, with an ID.
Definition: arm.h:88
uint32_t result
Result from the enum GNUNET_ARM_Result
Definition: arm.h:93
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:110
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:135
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:89
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:228
#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:115
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:59
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:

◆ check_arm_list_result()

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

Checked 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 304 of file arm_api.c.

References GNUNET_ARM_ListResultMessage::arm_msg, GNUNET_ARM_ListResultMessage::count, end, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_ARM_Message::header, and GNUNET_MessageHeader::size.

306 {
307  const char *pos = (const char *)&lres[1];
308  uint16_t rcount = ntohs(lres->count);
309  uint16_t msize = ntohs(lres->arm_msg.header.size) - sizeof(*lres);
310  uint16_t size_check;
311 
312  (void)cls;
313  size_check = 0;
314  for (unsigned int i = 0; i < rcount; i++)
315  {
316  const char *end = memchr(pos, 0, msize - size_check);
317  if (NULL == end)
318  {
319  GNUNET_break(0);
320  return GNUNET_SYSERR;
321  }
322  size_check += (end - pos) + 1;
323  pos = end + 1;
324  }
325  return GNUNET_OK;
326 }
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
struct GNUNET_ARM_Message arm_msg
Reply to client, of type is GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT, with an ID.
Definition: arm.h:107
#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;\0&#39; terminated strings that follow this message.
Definition: arm.h:113
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_MessageHeader header
Reply to client, type is GNUNET_MESSAGE_TYPE_ARM_RESULT or GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT.
Definition: arm.h:63
#define GNUNET_SYSERR
Definition: gnunet_common.h:76

◆ 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 336 of file arm_api.c.

References GNUNET_ARM_ListResultMessage::arm_msg, GNUNET_ARM_Operation::cont_cls, GNUNET_ARM_ListResultMessage::count, end, find_op_by_id(), GNUNET_ARM_operation_cancel(), GNUNET_ARM_REQUEST_SENT_OK, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ntohll(), GNUNET_ARM_Operation::h, GNUNET_ARM_Message::header, GNUNET_ARM_Operation::id, list, GNUNET_ARM_Operation::list_cont, LOG, op, GNUNET_ARM_Message::request_id, and GNUNET_MessageHeader::size.

338 {
339  struct GNUNET_ARM_Handle *h = cls;
340  uint16_t rcount = ntohs(lres->count);
341  const char *list[rcount];
342  const char *pos = (const char *)&lres[1];
343  uint16_t msize = ntohs(lres->arm_msg.header.size) - sizeof(*lres);
344  struct GNUNET_ARM_Operation *op;
345  uint16_t size_check;
346  uint64_t id;
347 
348  id = GNUNET_ntohll(lres->arm_msg.request_id);
349  op = find_op_by_id(h, id);
350  if (NULL == op)
351  {
353  "Message with unknown id %llu\n",
354  (unsigned long long)id);
355  return;
356  }
357  size_check = 0;
358  for (unsigned int i = 0; i < rcount; i++)
359  {
360  const char *end = memchr(pos, 0, msize - size_check);
361 
362  /* Assert, as this was already checked in #check_arm_list_result() */
363  GNUNET_assert(NULL != end);
364  list[i] = pos;
365  size_check += (end - pos) + 1;
366  pos = end + 1;
367  }
368  if (NULL != op->list_cont)
369  op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, rcount, list);
371 }
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:75
#define LOG(kind,...)
Definition: arm_api.c:33
#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:107
Handle for interacting with ARM.
Definition: arm_api.c:96
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:663
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:69
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;\0&#39; terminated strings that follow this message.
Definition: arm.h:113
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_ARM_ServiceListCallback list_cont
Callback for service list requests.
Definition: arm_api.c:64
struct GNUNET_MessageHeader header
Reply to client, type is GNUNET_MESSAGE_TYPE_ARM_RESULT or GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT.
Definition: arm.h:63
Message was sent successfully.
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:228
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:64
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 381 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.

382 {
383  struct GNUNET_ARM_Handle *h = cls;
384 
385  (void)msg;
386  LOG(GNUNET_ERROR_TYPE_DEBUG, "Got confirmation from ARM that we are up!\n");
387  if (GNUNET_NO == h->currently_up)
388  {
390  if (NULL != h->conn_status)
392  }
393 }
#define LOG(kind,...)
Definition: arm_api.c:33
Handle for interacting with ARM.
Definition: arm_api.c:96
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:120
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:125
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:156
#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 405 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().

406 {
407  struct GNUNET_ARM_Handle *h = cls;
408  struct GNUNET_ARM_Operation *op;
409 
410  (void)error;
411  h->currently_up = GNUNET_NO;
412  if (NULL != (op = h->thm))
413  {
414  h->thm = NULL;
415  op->result_cont(op->cont_cls,
418  GNUNET_free(op);
419  }
421 }
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:96
#define GNUNET_NO
Definition: gnunet_common.h:78
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:69
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
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:192
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:135
Message was sent successfully.
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:156
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
Service was stopped (never sent for ARM itself).
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:59
#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 
)
static

A client specifically requested starting of ARM itself.

Starts the ARM service.

Parameters
hthe handle with configuration details
std_inheritanceinheritance of std streams
Returns
operation status code

Definition at line 549 of file arm_api.c.

References GNUNET_ARM_Handle::cfg, config, 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().

551 {
552  struct GNUNET_OS_Process *proc;
553  char *cbinary;
554  char *binary;
555  char *quotedbinary;
556  char *config;
557  char *loprefix;
558  char *lopostfix;
559 
561  "arm",
562  "PREFIX",
563  &loprefix))
564  loprefix = GNUNET_strdup("");
565  else
566  loprefix = GNUNET_CONFIGURATION_expand_dollar(h->cfg, loprefix);
568  "arm",
569  "OPTIONS",
570  &lopostfix))
571  lopostfix = GNUNET_strdup("");
572  else
573  lopostfix = GNUNET_CONFIGURATION_expand_dollar(h->cfg, lopostfix);
574  if (GNUNET_OK !=
575  GNUNET_CONFIGURATION_get_value_string(h->cfg, "arm", "BINARY", &cbinary))
576  {
578  GNUNET_free(loprefix);
579  GNUNET_free(lopostfix);
581  }
583  "arm",
584  "CONFIG",
585  &config))
586  config = NULL;
587  binary = GNUNET_OS_get_libexec_binary_path(cbinary);
588  GNUNET_asprintf(&quotedbinary, "\"%s\"", binary);
589  GNUNET_free(cbinary);
590  if ((GNUNET_YES ==
591  GNUNET_CONFIGURATION_have_value(h->cfg, "TESTING", "WEAKRANDOM")) &&
593  "TESTING",
594  "WEAKRANDOM")) &&
595  (GNUNET_NO ==
596  GNUNET_CONFIGURATION_have_value(h->cfg, "TESTING", "HOSTFILE")))
597  {
598  /* Means we are ONLY running locally */
599  /* we're clearly running a test, don't daemonize */
600  if (NULL == config)
602  std_inheritance,
603  NULL,
604  loprefix,
605  quotedbinary,
606  /* no daemonization! */
607  lopostfix,
608  NULL);
609  else
611  std_inheritance,
612  NULL,
613  loprefix,
614  quotedbinary,
615  "-c",
616  config,
617  /* no daemonization! */
618  lopostfix,
619  NULL);
620  }
621  else
622  {
623  if (NULL == config)
625  std_inheritance,
626  NULL,
627  loprefix,
628  quotedbinary,
629  "-d", /* do daemonize */
630  lopostfix,
631  NULL);
632  else
634  std_inheritance,
635  NULL,
636  loprefix,
637  quotedbinary,
638  "-c",
639  config,
640  "-d", /* do daemonize */
641  lopostfix,
642  NULL);
643  }
644  GNUNET_free(binary);
645  GNUNET_free(quotedbinary);
646  GNUNET_free_non_null(config);
647  GNUNET_free(loprefix);
648  GNUNET_free(lopostfix);
649  if (NULL == proc)
653 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:105
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:286
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...
struct GNUNET_OS_Process * GNUNET_OS_start_process_s(int pipe_control, unsigned int std_inheritance, const SOCKTYPE *lsocks, const char *filename,...)
Start a process.
Definition: os_priority.c:762
#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.
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 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 690 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().

695 {
696  struct GNUNET_ARM_Operation *op;
697  size_t slen;
698  struct GNUNET_MQ_Envelope *env;
699  struct GNUNET_ARM_Message *msg;
700 
701  slen = strlen(service_name) + 1;
702  if (slen + sizeof(struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE)
703  {
704  GNUNET_break(0);
705  return NULL;
706  }
707  if (0 == h->request_id_counter)
708  h->request_id_counter++;
709  op = GNUNET_new(struct GNUNET_ARM_Operation);
710  op->h = h;
711  op->result_cont = cb;
712  op->cont_cls = cb_cls;
713  op->id = h->request_id_counter++;
716  op);
717  env = GNUNET_MQ_msg_extra(msg, slen, type);
718  msg->reserved = htonl(0);
719  msg->request_id = GNUNET_htonll(op->id);
720  GNUNET_memcpy(&msg[1], service_name, slen);
721  GNUNET_MQ_send(h->mq, env);
722  return op;
723 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint64_t request_id
ID of a request that is being replied to.
Definition: arm.h:75
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:100
#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:69
uint32_t reserved
For alignment.
Definition: arm.h:68
#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:94
#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:110
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:79
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:54
uint64_t request_id_counter
Counter for request identifiers.
Definition: arm_api.c:151
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:351
struct GNUNET_ARM_Operation * operation_pending_tail
Tail of doubly-linked list of pending operations.
Definition: arm_api.c:115
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:59
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 732 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().

733 {
734  struct GNUNET_ARM_Operation *op = cls;
735  struct GNUNET_ARM_Handle *h = op->h;
736 
737  op->async = NULL;
740  op);
741  if (NULL != op->result_cont)
742  op->result_cont(op->cont_cls,
745  if ((GNUNET_YES == h->currently_up) && (NULL != h->conn_status))
747  GNUNET_free(op);
748 }
#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:96
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:69
Asked to start it, but it&#39;s already started.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_SCHEDULER_Task * async
Task for async completion.
Definition: arm_api.c:74
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:120
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:110
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:125
Message was sent successfully.
struct GNUNET_ARM_Handle * h
ARM handle.
Definition: arm_api.c:54
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:156
#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:115
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:59
#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 757 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().

758 {
759  struct GNUNET_ARM_Operation *op = cls;
760  struct GNUNET_ARM_Handle *h = op->h;
761 
762  op->async = NULL;
764  "Notifying client that we started the ARM service\n");
767  op);
768  if (NULL != op->result_cont)
769  op->result_cont(op->cont_cls,
771  op->starting_ret);
772  GNUNET_free(op);
773 }
#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:96
void * cont_cls
Closure for result_cont or list_cont.
Definition: arm_api.c:69
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_SCHEDULER_Task * async
Task for async completion.
Definition: arm_api.c:74
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:110
Message was sent successfully.
struct GNUNET_ARM_Handle * h
ARM handle.
Definition: arm_api.c:54
enum GNUNET_ARM_Result starting_ret
Result of this operation for notify_starting().
Definition: arm_api.c:84
struct GNUNET_ARM_Operation * operation_pending_tail
Tail of doubly-linked list of pending operations.
Definition: arm_api.c:115
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
GNUNET_ARM_ResultCallback result_cont
Callback for service state change requests.
Definition: arm_api.c:59
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function: