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

434 {
436  {GNUNET_MQ_hd_fixed_size (arm_result,
439  h),
440  GNUNET_MQ_hd_var_size (arm_list_result,
443  h),
444  GNUNET_MQ_hd_fixed_size (confirm,
446  struct GNUNET_MessageHeader,
447  h),
449  struct GNUNET_MessageHeader *test;
450  struct GNUNET_MQ_Envelope *env;
451 
452  if (NULL != h->mq)
453  return GNUNET_OK;
455  h->mq = GNUNET_CLIENT_connect (h->cfg, "arm", handlers, &mq_error_handler, h);
456  if (NULL == h->mq)
457  {
458  LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CLIENT_connect returned NULL\n");
459  if (NULL != h->conn_status)
461  return GNUNET_SYSERR;
462  }
463  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending TEST message to ARM\n");
465  GNUNET_MQ_send (h->mq, env);
466  return GNUNET_OK;
467 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:107
#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:901
#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:102
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_ARM_ConnectionStatusCallback conn_status
Callback to invoke on connection/disconnection.
Definition: arm_api.c:122
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:79
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:107
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:127
#define GNUNET_MESSAGE_TYPE_ARM_TEST
Test if ARM service is online.
Reply from ARM to client.
Definition: arm.h:87
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:158
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:407
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 178 of file arm_api.c.

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

Referenced by reconnect_arm_later().

179 {
180  struct GNUNET_ARM_Handle *h = cls;
181 
182  h->reconnect_task = NULL;
183  reconnect_arm (h);
184 }
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:142
Handle for interacting with ARM.
Definition: arm_api.c:97
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:433
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 194 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().

195 {
196  struct GNUNET_ARM_Operation *op;
197 
198  if (NULL != h->mq)
199  {
200  GNUNET_MQ_destroy (h->mq);
201  h->mq = NULL;
202  }
203  h->currently_up = GNUNET_NO;
204  GNUNET_assert (NULL == h->reconnect_task);
205  h->reconnect_task =
207  while (NULL != (op = h->operation_pending_head))
208  {
209  if (NULL != op->result_cont)
211  if (NULL != op->list_cont)
214  }
217  if (NULL != h->conn_status)
219 }
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:142
#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:178
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:102
#define GNUNET_NO
Definition: gnunet_common.h:81
void GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
Abort an operation.
Definition: arm_api.c:665
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:122
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:1246
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:112
#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:127
struct GNUNET_TIME_Relative retry_backoff
Current delay we use for re-trying to connect to core.
Definition: arm_api.c:147
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:158
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:139
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 230 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().

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

250 {
251  struct GNUNET_ARM_Handle *h = cls;
252  struct GNUNET_ARM_Operation *op;
253  uint64_t id;
256  void *result_cont_cls;
257 
258  id = GNUNET_ntohll (res->arm_msg.request_id);
259  op = find_op_by_id (h, id);
260  if (NULL == op)
261  {
263  "Message with unknown id %llu\n",
264  (unsigned long long) id);
265  return;
266  }
267 
268  result = (enum GNUNET_ARM_Result) ntohl (res->result);
270  {
271  /* special case: if we are stopping 'gnunet-service-arm', we do not just
272  wait for the result message, but also wait for the service to close
273  the connection (and then we have to close our client handle as well);
274  this is done by installing a different receive handler, waiting for
275  the connection to go down */
276  if (NULL != h->thm)
277  {
278  GNUNET_break (0);
279  op->result_cont (h->thm->cont_cls,
282  GNUNET_free (h->thm);
283  }
286  op);
287  h->thm = op;
288  return;
289  }
290  result_cont = op->result_cont;
291  result_cont_cls = op->cont_cls;
293  if (NULL != result_cont)
294  result_cont (result_cont_cls, GNUNET_ARM_REQUEST_SENT_OK, result);
295 }
#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:78
#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:97
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:665
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:94
struct GNUNET_ARM_Message arm_msg
Reply to client, of type is GNUNET_MESSAGE_TYPE_ARM_RESULT, with an ID.
Definition: arm.h:93
uint32_t result
Result from the enum GNUNET_ARM_Result
Definition: arm.h:98
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:112
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:137
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:90
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:230
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_ARM_Operation * operation_pending_tail
Tail of doubly-linked list of pending operations.
Definition: arm_api.c:117
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: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:

◆ 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 306 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.

308 {
309  const char *pos = (const char *) &lres[1];
310  uint16_t rcount = ntohs (lres->count);
311  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof (*lres);
312  uint16_t size_check;
313 
314  (void) cls;
315  size_check = 0;
316  for (unsigned int i = 0; i < rcount; i++)
317  {
318  const char *end = memchr (pos, 0, msize - size_check);
319  if (NULL == end)
320  {
321  GNUNET_break (0);
322  return GNUNET_SYSERR;
323  }
324  size_check += (end - pos) + 1;
325  pos = end + 1;
326  }
327  return GNUNET_OK;
328 }
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:113
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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:119
#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:66
#define GNUNET_SYSERR
Definition: gnunet_common.h:79

◆ 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 338 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.

340 {
341  struct GNUNET_ARM_Handle *h = cls;
342  uint16_t rcount = ntohs (lres->count);
343  const char *list[rcount];
344  const char *pos = (const char *) &lres[1];
345  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof (*lres);
346  struct GNUNET_ARM_Operation *op;
347  uint16_t size_check;
348  uint64_t id;
349 
350  id = GNUNET_ntohll (lres->arm_msg.request_id);
351  op = find_op_by_id (h, id);
352  if (NULL == op)
353  {
355  "Message with unknown id %llu\n",
356  (unsigned long long) id);
357  return;
358  }
359  size_check = 0;
360  for (unsigned int i = 0; i < rcount; i++)
361  {
362  const char *end = memchr (pos, 0, msize - size_check);
363 
364  /* Assert, as this was already checked in #check_arm_list_result() */
365  GNUNET_assert (NULL != end);
366  list[i] = pos;
367  size_check += (end - pos) + 1;
368  pos = end + 1;
369  }
370  if (NULL != op->list_cont)
371  op->list_cont (op->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, rcount, list);
373 }
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:78
#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:113
Handle for interacting with ARM.
Definition: arm_api.c:97
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:665
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;\0&#39; terminated strings that follow this message.
Definition: arm.h:119
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: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:66
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:230
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 383 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.

384 {
385  struct GNUNET_ARM_Handle *h = cls;
386 
387  (void) msg;
388  LOG (GNUNET_ERROR_TYPE_DEBUG, "Got confirmation from ARM that we are up!\n");
389  if (GNUNET_NO == h->currently_up)
390  {
392  if (NULL != h->conn_status)
394  }
395 }
#define LOG(kind,...)
Definition: arm_api.c:33
Handle for interacting with ARM.
Definition: arm_api.c:97
#define GNUNET_NO
Definition: gnunet_common.h:81
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:122
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:127
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:158
#define GNUNET_YES
Definition: gnunet_common.h:80

◆ 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 407 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().

408 {
409  struct GNUNET_ARM_Handle *h = cls;
410  struct GNUNET_ARM_Operation *op;
411 
412  (void) error;
413  h->currently_up = GNUNET_NO;
414  if (NULL != (op = h->thm))
415  {
416  h->thm = NULL;
417  op->result_cont (op->cont_cls,
420  GNUNET_free (op);
421  }
423 }
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:97
#define GNUNET_NO
Definition: gnunet_common.h:81
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: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:194
struct GNUNET_ARM_Operation * thm
ARM operation where the goal is to wait for ARM shutdown to complete.
Definition: arm_api.c:137
Message was sent successfully.
int currently_up
Have we detected that ARM is up?
Definition: arm_api.c:158
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: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 
)
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 551 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().

553 {
554  struct GNUNET_OS_Process *proc;
555  char *cbinary;
556  char *binary;
557  char *quotedbinary;
558  char *config;
559  char *loprefix;
560  char *lopostfix;
561 
563  "arm",
564  "PREFIX",
565  &loprefix))
566  loprefix = GNUNET_strdup ("");
567  else
568  loprefix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, loprefix);
570  "arm",
571  "OPTIONS",
572  &lopostfix))
573  lopostfix = GNUNET_strdup ("");
574  else
575  lopostfix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, lopostfix);
576  if (GNUNET_OK !=
577  GNUNET_CONFIGURATION_get_value_string (h->cfg, "arm", "BINARY", &cbinary))
578  {
580  GNUNET_free (loprefix);
581  GNUNET_free (lopostfix);
583  }
585  "arm",
586  "CONFIG",
587  &config))
588  config = NULL;
589  binary = GNUNET_OS_get_libexec_binary_path (cbinary);
590  GNUNET_asprintf (&quotedbinary, "\"%s\"", binary);
591  GNUNET_free (cbinary);
592  if ((GNUNET_YES ==
593  GNUNET_CONFIGURATION_have_value (h->cfg, "TESTING", "WEAKRANDOM")) &&
595  "TESTING",
596  "WEAKRANDOM")) &&
597  (GNUNET_NO ==
598  GNUNET_CONFIGURATION_have_value (h->cfg, "TESTING", "HOSTFILE")))
599  {
600  /* Means we are ONLY running locally */
601  /* we're clearly running a test, don't daemonize */
602  if (NULL == config)
604  std_inheritance,
605  NULL,
606  loprefix,
607  quotedbinary,
608  /* no daemonization! */
609  lopostfix,
610  NULL);
611  else
613  std_inheritance,
614  NULL,
615  loprefix,
616  quotedbinary,
617  "-c",
618  config,
619  /* no daemonization! */
620  lopostfix,
621  NULL);
622  }
623  else
624  {
625  if (NULL == config)
627  std_inheritance,
628  NULL,
629  loprefix,
630  quotedbinary,
631  "-d", /* do daemonize */
632  lopostfix,
633  NULL);
634  else
636  std_inheritance,
637  NULL,
638  loprefix,
639  quotedbinary,
640  "-c",
641  config,
642  "-d", /* do daemonize */
643  lopostfix,
644  NULL);
645  }
646  GNUNET_free (binary);
647  GNUNET_free (quotedbinary);
648  GNUNET_free_non_null (config);
649  GNUNET_free (loprefix);
650  GNUNET_free (lopostfix);
651  if (NULL == proc)
655 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:107
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:364
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:1474
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#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:80
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 692 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().

697 {
698  struct GNUNET_ARM_Operation *op;
699  size_t slen;
700  struct GNUNET_MQ_Envelope *env;
701  struct GNUNET_ARM_Message *msg;
702 
703  slen = strlen (service_name) + 1;
704  if (slen + sizeof (struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE)
705  {
706  GNUNET_break (0);
707  return NULL;
708  }
709  if (0 == h->request_id_counter)
710  h->request_id_counter++;
711  op = GNUNET_new (struct GNUNET_ARM_Operation);
712  op->h = h;
713  op->result_cont = cb;
714  op->cont_cls = cb_cls;
715  op->id = h->request_id_counter++;
718  op);
719  env = GNUNET_MQ_msg_extra (msg, slen, type);
720  msg->reserved = htonl (0);
721  msg->request_id = GNUNET_htonll (op->id);
722  GNUNET_memcpy (&msg[1], service_name, slen);
723  GNUNET_MQ_send (h->mq, env);
724  return op;
725 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint64_t request_id
ID of a request that is being replied to.
Definition: arm.h:78
Entry in a doubly-linked list of operations awaiting for replies (in-order) from the ARM service...
Definition: arm_api.c:40
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:102
#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:71
#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
#define GNUNET_memcpy(dst, src, n)
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:112
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:153
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:117
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: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 734 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().

735 {
736  struct GNUNET_ARM_Operation *op = cls;
737  struct GNUNET_ARM_Handle *h = op->h;
738 
739  op->async = NULL;
742  op);
743  if (NULL != op->result_cont)
744  op->result_cont (op->cont_cls,
747  if ((GNUNET_YES == h->currently_up) && (NULL != h->conn_status))
749  GNUNET_free (op);
750 }
#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:97
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:94
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:122
struct GNUNET_ARM_Operation * operation_pending_head
Head of doubly-linked list of pending operations.
Definition: arm_api.c:112
void * conn_status_cls
Closure for conn_status.
Definition: arm_api.c:127
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:158
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_ARM_Operation * operation_pending_tail
Tail of doubly-linked list of pending operations.
Definition: arm_api.c:117
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: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 759 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().

760 {
761  struct GNUNET_ARM_Operation *op = cls;
762  struct GNUNET_ARM_Handle *h = op->h;
763 
764  op->async = NULL;
766  "Notifying client that we started the ARM service\n");
769  op);
770  if (NULL != op->result_cont)
771  op->result_cont (op->cont_cls,
773  op->starting_ret);
774  GNUNET_free (op);
775 }
#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:97
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:94
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:112
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:117
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:60
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function: