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 enum GNUNET_GenericReturnValue	reconnect_arm (struct GNUNET_ARM_Handle *h)
	Connect to arm.
static void	reconnect_arm_task (void *cls)
	Task scheduled to try to re-connect to arm.
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.
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.
static void	handle_arm_result (void *cls, const struct GNUNET_ARM_ResultMessage *res)
	Handler for ARM replies.
static const char *	pool_get (const char *pool_start, size_t pool_size, size_t str_index)
	Read from a string pool.
static enum GNUNET_GenericReturnValue	check_arm_list_result (void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
	Check that list result message is well-formed.
static void	handle_arm_list_result (void *cls, const struct GNUNET_ARM_ListResultMessage *lres)
	Handler for ARM list replies.
static void	handle_confirm (void *cls, const struct GNUNET_MessageHeader *msg)
	Receive confirmation from test, ARM service is up.
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.
struct GNUNET_ARM_Handle *	GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ARM_ConnectionStatusCallback conn_status, void *conn_status_cls)
	Set up a context for communicating with ARM, then start connecting to the ARM service using that context.
void	GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h)
	Disconnect from the ARM service (if connected) and destroy the context.
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.
void	GNUNET_ARM_operation_cancel (struct GNUNET_ARM_Operation *op)
	Abort an operation.
static struct GNUNET_ARM_Operation *	change_service (struct GNUNET_ARM_Handle *h, const char *service_name, GNUNET_ARM_ResultCallback cb, void *cb_cls, uint16_t type)
	Start or stop a service.
static void	notify_running (void *cls)
	Task run to notify application that ARM is already up.
static void	notify_starting (void *cls)
	Task run to notify application that ARM is being started.
struct GNUNET_ARM_Operation *	GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h, const char *service_name, enum GNUNET_OS_InheritStdioFlags std_inheritance, GNUNET_ARM_ResultCallback cont, void *cont_cls)
	Request for a service to be started.
struct GNUNET_ARM_Operation *	GNUNET_ARM_request_service_stop (struct GNUNET_ARM_Handle *h, const char *service_name, GNUNET_ARM_ResultCallback cont, void *cont_cls)
	Request a service to be stopped.
struct GNUNET_ARM_Operation *	GNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h, GNUNET_ARM_ServiceListCallback cont, void *cont_cls)
	Request a list of running services.

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.

Function Documentation

reconnect_arm()

static enum GNUNET_GenericReturnValue reconnect_arm ( struct GNUNET_ARM_Handle *  h )

static

Connect to arm.

Parameters

h	arm handle

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 519 of file arm_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (arm_result,
                             GNUNET_MESSAGE_TYPE_ARM_RESULT,
                             struct GNUNET_ARM_ResultMessage,
                             h),
    GNUNET_MQ_hd_var_size (arm_list_result,
                           GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT,
                           struct GNUNET_ARM_ListResultMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (confirm,
                             GNUNET_MESSAGE_TYPE_ARM_TEST,
                             struct GNUNET_MessageHeader,
                             h),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MessageHeader *test;
  struct GNUNET_MQ_Envelope *env;
 
  if (NULL != h->mq)
    return GNUNET_OK;
  GNUNET_assert (GNUNET_NO == h->currently_up);
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "arm",
                                 handlers,
                                 &mq_error_handler,
                                 h);
  if (NULL == h->mq)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "GNUNET_CLIENT_connect returned NULL\n");
    if (NULL != h->conn_status)
      h->conn_status (h->conn_status_cls,
                      GNUNET_SYSERR);
    return GNUNET_SYSERR;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending TEST message to ARM\n");
  env = GNUNET_MQ_msg (test,
                       GNUNET_MESSAGE_TYPE_ARM_TEST);
  GNUNET_MQ_send (h->mq, env);
  return GNUNET_OK;
}

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, h, handlers, LOG, GNUNET_ARM_Handle::mq, and mq_error_handler().

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

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

cls	the struct GNUNET_ARM_Handle

Definition at line 183 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h = cls;
 
  h->reconnect_task = NULL;
  reconnect_arm (h);
}

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

Referenced by reconnect_arm_later().

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

h	our handle

Definition at line 199 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op;
 
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  h->currently_up = GNUNET_NO;
  GNUNET_assert (NULL == h->reconnect_task);
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
                                  &reconnect_arm_task,
                                  h);
  while (NULL != (op = h->operation_pending_head))
  {
    if (NULL != op->result_cont)
      op->result_cont (op->cont_cls,
                       GNUNET_ARM_REQUEST_DISCONNECTED,
                       0);
    if (NULL != op->list_cont)
      op->list_cont (op->cont_cls,
                     GNUNET_ARM_REQUEST_DISCONNECTED,
                     0,
                     NULL);
    GNUNET_ARM_operation_cancel (op);
  }
  GNUNET_assert (NULL == h->operation_pending_head);
  h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff);
  if (NULL != h->conn_status)
    h->conn_status (h->conn_status_cls,
                    GNUNET_NO);
}

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, h, 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().

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

h	ARM handle
id	unique message ID to use for the lookup

Returns

NULL if not found

Definition at line 243 of file arm_api.c.

{
  for (struct GNUNET_ARM_Operation *result = h->operation_pending_head;
       NULL != result;
       result = result->next)
    if (id == result->id)
      return result;
  return NULL;
}

References h, GNUNET_ARM_Handle::operation_pending_head, and result.

Referenced by handle_arm_list_result(), and handle_arm_result().

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

cls	our struct GNUNET_ARM_Handle
res	the message received from the arm service

Definition at line 262 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h = cls;
  struct GNUNET_ARM_Operation *op;
  uint64_t id;
  enum GNUNET_ARM_Result result;
  GNUNET_ARM_ResultCallback result_cont;
  void *result_cont_cls;
 
  id = GNUNET_ntohll (res->arm_msg.request_id);
  op = find_op_by_id (h,
                      id);
  if (NULL == op)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Message with unknown id %llu\n",
         (unsigned long long) id);
    return;
  }
 
  result = ntohl (res->result);
  if ( (GNUNET_YES == op->is_arm_stop) &&
       (GNUNET_ARM_RESULT_STOPPING == result) )
  {
    /* special case: if we are stopping 'gnunet-service-arm', we do not just
       wait for the result message, but also wait for the service to close
       the connection (and then we have to close our client handle as well);
       this is done by installing a different receive handler, waiting for
       the connection to go down */if (NULL != h->thm)
    {
      GNUNET_break (0);
      op->result_cont (h->thm->cont_cls,
                       GNUNET_ARM_REQUEST_SENT_OK,
                       GNUNET_ARM_RESULT_IS_NOT_KNOWN);
      GNUNET_free (h->thm);
    }
    GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
                                 h->operation_pending_tail,
                                 op);
    h->thm = op;
    return;
  }
  result_cont = op->result_cont;
  result_cont_cls = op->cont_cls;
  GNUNET_ARM_operation_cancel (op);
  if (NULL != result_cont)
    result_cont (result_cont_cls,
                 GNUNET_ARM_REQUEST_SENT_OK,
                 result);
}

References 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, h, id, GNUNET_ARM_Operation::is_arm_stop, LOG, op, GNUNET_ARM_Handle::operation_pending_head, GNUNET_ARM_Handle::operation_pending_tail, res, result, GNUNET_ARM_Operation::result_cont, and GNUNET_ARM_Handle::thm.

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_start	start of the string pool
pool_size	size of the string pool
str_index	index 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.

{
  const char *str_start;
  const char *end;
 
  if (str_index >= pool_size)
    return NULL;
  str_start = pool_start + str_index;
  end = memchr (str_start, 0, pool_size - str_index);
  if (NULL == end)
    return NULL;
  return str_start;
}

References end.

Referenced by check_arm_list_result(), and handle_arm_list_result().

Here is the caller graph for this function:

check_arm_list_result()

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

static

Check that list result message is well-formed.

Parameters

cls	our struct GNUNET_ARM_Handle
lres	the message received from the arm service

Returns

GNUNET_OK if message is well-formed

Definition at line 350 of file arm_api.c.

{
  uint16_t rcount = ntohs (lres->count);
  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres);
  struct GNUNET_ARM_ServiceInfoMessage *ssm;
  size_t pool_size;
  char *pool_start;
 
  (void) cls;
  if ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) > msize))
  {
    GNUNET_break_op (0);
    return GNUNET_NO;
  }
  ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1];
  pool_start = (char *) (ssm + rcount);
  pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage));
  for (unsigned int i = 0; i < rcount; i++)
  {
    uint16_t name_index = ntohs (ssm->name_index);
    uint16_t binary_index = ntohs (ssm->binary_index);
    if (NULL == pool_get (pool_start,
                          pool_size,
                          name_index))
    {
      GNUNET_break_op (0);
      return GNUNET_NO;
    }
    if (NULL == pool_get (pool_start,
                          pool_size,
                          binary_index))
    {
      GNUNET_break_op (0);
      return GNUNET_NO;
    }
    ssm++;
  }
  return GNUNET_OK;
}

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.

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

cls	our struct GNUNET_ARM_Handle
lres	the message received from the arm service

Definition at line 399 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h = cls;
  uint16_t rcount = ntohs (lres->count);
  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres);
  struct GNUNET_ARM_ServiceInfo list[rcount];
  struct GNUNET_ARM_ServiceInfoMessage *ssm;
  struct GNUNET_ARM_Operation *op;
  uint64_t id;
  size_t pool_size;
  char *pool_start;
 
  id = GNUNET_ntohll (lres->arm_msg.request_id);
  op = find_op_by_id (h, id);
  if (NULL == op)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Message with unknown id %llu\n",
         (unsigned long long) id);
    return;
  }
 
  GNUNET_assert ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) <=
                  msize));
 
  ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1];
  pool_start = (char *) (ssm + rcount);
  pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage));
 
  for (unsigned int i = 0; i < rcount; i++)
  {
    uint16_t name_index = ntohs (ssm->name_index);
    uint16_t binary_index = ntohs (ssm->binary_index);
    const char *name;
    const char *binary;
 
    name = pool_get (pool_start, pool_size, name_index);
    binary = pool_get (pool_start, pool_size, binary_index);
    GNUNET_assert (NULL != name);
    GNUNET_assert (NULL != binary);
    list[i] = (struct GNUNET_ARM_ServiceInfo) {
      .name = name,
      .binary = binary,
      .status = ntohl (ssm->status),
      .last_started_at = GNUNET_TIME_absolute_ntoh (ssm->last_started_at),
      .restart_at = GNUNET_TIME_absolute_ntoh (ssm->restart_at),
      .last_exit_status = ntohs (ssm->last_exit_status),
    };
    ssm++;
  }
  if (NULL != op->list_cont)
    op->list_cont (op->cont_cls,
                   GNUNET_ARM_REQUEST_SENT_OK,
                   rcount,
                   list);
  GNUNET_ARM_operation_cancel (op);
}

References GNUNET_ARM_ListResultMessage::arm_msg, GNUNET_ARM_ServiceInfo::binary, 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(), h, GNUNET_ARM_Message::header, id, GNUNET_ARM_ServiceInfoMessage::last_exit_status, GNUNET_ARM_ServiceInfoMessage::last_started_at, list, GNUNET_ARM_Operation::list_cont, LOG, name, GNUNET_ARM_ServiceInfo::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.

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

cls	closure with the struct GNUNET_ARM_Handle
msg	message received

Definition at line 466 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h = cls;
 
  (void) msg;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got confirmation from ARM that we are up!\n");
  if (GNUNET_NO == h->currently_up)
  {
    h->currently_up = GNUNET_YES;
    if (NULL != h->conn_status)
      h->conn_status (h->conn_status_cls, GNUNET_YES);
  }
}

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, h, LOG, and msg.

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

cls	closure with the struct GNUNET_ARM_Handle *
error	error code

Definition at line 492 of file arm_api.c.

{
  struct GNUNET_ARM_Handle *h = cls;
  struct GNUNET_ARM_Operation *op;
 
  (void) error;
  h->currently_up = GNUNET_NO;
  if (NULL != (op = h->thm))
  {
    h->thm = NULL;
    op->result_cont (op->cont_cls,
                     GNUNET_ARM_REQUEST_SENT_OK,
                     GNUNET_ARM_RESULT_STOPPED);
    GNUNET_free (op);
  }
  reconnect_arm_later (h);
}

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

Referenced by reconnect_arm().

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

h	the handle with configuration details
std_inheritance	inheritance of std streams
sigfd	socket to pass to ARM for signalling

Returns

operation status code

Definition at line 654 of file arm_api.c.

{
  struct GNUNET_OS_Process *proc;
  char *cbinary;
  char *binary;
  char *quotedbinary;
  char *config;
  char *loprefix;
  char *lopostfix;
  int ld[2];
  int *lsocks;
 
  if (NULL == sigfd)
  {
    lsocks = NULL;
  }
  else
  {
    ld[0] = sigfd->fd;
    ld[1] = -1;
    lsocks = ld;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (h->cfg,
                                             "arm",
                                             "PREFIX",
                                             &loprefix))
    loprefix = GNUNET_strdup ("");
  else
    loprefix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, loprefix);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (h->cfg,
                                             "arm",
                                             "OPTIONS",
                                             &lopostfix))
    lopostfix = GNUNET_strdup ("");
  else
    lopostfix = GNUNET_CONFIGURATION_expand_dollar (h->cfg,
                                                    lopostfix);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (h->cfg,
                                             "arm",
                                             "BINARY",
                                             &cbinary))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
                               "arm",
                               "BINARY");
    GNUNET_free (loprefix);
    GNUNET_free (lopostfix);
    return GNUNET_ARM_RESULT_IS_NOT_KNOWN;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (h->cfg,
                                               "arm",
                                               "CONFIG",
                                               &config))
    config = NULL;
  binary = GNUNET_OS_get_libexec_binary_path (GNUNET_OS_project_data_gnunet (),
                                              cbinary);
  GNUNET_asprintf (&quotedbinary,
                   "\"%s\"",
                   binary);
  GNUNET_free (cbinary);
  if ( (GNUNET_YES ==
        GNUNET_CONFIGURATION_have_value (h->cfg,
                                         "TESTING",
                                         "WEAKRANDOM")) &&
       (GNUNET_YES ==
        GNUNET_CONFIGURATION_get_value_yesno (h->cfg,
                                              "TESTING",
                                              "WEAKRANDOM")) &&
       (GNUNET_NO ==
        GNUNET_CONFIGURATION_have_value (h->cfg,
                                         "TESTING",
                                         "HOSTFILE")) )
  {
    /* Means we are ONLY running locally */
    /* we're clearly running a test, don't daemonize */
    if (NULL == config)
      proc = GNUNET_OS_start_process_s (std_inheritance,
                                        lsocks,
                                        loprefix,
                                        quotedbinary,
                                        /* no daemonization! */
                                        lopostfix,
                                        NULL);
    else
      proc = GNUNET_OS_start_process_s (std_inheritance,
                                        lsocks,
                                        loprefix,
                                        quotedbinary,
                                        "-c",
                                        config,
                                        /* no daemonization! */
                                        lopostfix,
                                        NULL);
  }
  else
  {
    if (NULL == config)
      proc = GNUNET_OS_start_process_s (std_inheritance,
                                        lsocks,
                                        loprefix,
                                        quotedbinary,
                                        "-d",  /* do daemonize */
                                        lopostfix,
                                        NULL);
    else
      proc = GNUNET_OS_start_process_s (std_inheritance,
                                        lsocks,
                                        loprefix,
                                        quotedbinary,
                                        "-c",
                                        config,
                                        "-d",  /* do daemonize */
                                        lopostfix,
                                        NULL);
  }
  GNUNET_free (binary);
  GNUNET_free (quotedbinary);
  if (NULL != config)
    GNUNET_free (config);
  GNUNET_free (loprefix);
  GNUNET_free (lopostfix);
  if (NULL == proc)
    return GNUNET_ARM_RESULT_START_FAILED;
  GNUNET_OS_process_destroy (proc);
  return GNUNET_ARM_RESULT_STARTING;
}

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_log_config_missing(), GNUNET_NO, GNUNET_OK, GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_process_destroy(), GNUNET_OS_project_data_gnunet(), GNUNET_OS_start_process_s(), GNUNET_strdup, GNUNET_YES, and h.

Referenced by GNUNET_ARM_request_service_start().

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

h	handle to ARM
service_name	name of the service
cb	callback to invoke when service is ready
cb_cls	closure for cb
type	type of the request

Returns

handle to queue, NULL on error

Definition at line 832 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op;
  size_t slen;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_ARM_Message *msg;
 
  slen = strlen (service_name) + 1;
  if (slen + sizeof(struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (0 == h->request_id_counter)
    h->request_id_counter++;
  op = GNUNET_new (struct GNUNET_ARM_Operation);
  op->h = h;
  op->result_cont = cb;
  op->cont_cls = cb_cls;
  op->id = h->request_id_counter++;
  GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
                                    h->operation_pending_tail,
                                    op);
  env = GNUNET_MQ_msg_extra (msg,
                             slen,
                             type);
  msg->reserved = htonl (0);
  msg->request_id = GNUNET_htonll (op->id);
  GNUNET_memcpy (&msg[1],
                 service_name,
                 slen);
  GNUNET_MQ_send (h->mq, env);
  return op;
}

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, h, 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_Handle::request_id_counter, GNUNET_ARM_Operation::result_cont, service_name, and type.

Referenced by GNUNET_ARM_request_service_start(), and GNUNET_ARM_request_service_stop().

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

cls	the operation that asked ARM to be started

Definition at line 878 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op = cls;
  struct GNUNET_ARM_Handle *h = op->h;
 
  op->async = NULL;
  GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
                               h->operation_pending_tail,
                               op);
  if (NULL != op->result_cont)
    op->result_cont (op->cont_cls,
                     GNUNET_ARM_REQUEST_SENT_OK,
                     GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
  if ( (GNUNET_YES == h->currently_up) &&
       (NULL != h->conn_status) )
    h->conn_status (h->conn_status_cls,
                    GNUNET_YES);
  GNUNET_free (op);
}

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, h, 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().

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

cls	the operation that asked ARM to be started

Definition at line 905 of file arm_api.c.

{
  struct GNUNET_ARM_Operation *op = cls;
  struct GNUNET_ARM_Handle *h = op->h;
 
  op->async = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying client that we started the ARM service\n");
  GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
                               h->operation_pending_tail,
                               op);
  if (NULL != op->result_cont)
    op->result_cont (op->cont_cls,
                     GNUNET_ARM_REQUEST_SENT_OK,
                     op->starting_ret);
  GNUNET_DISK_file_close (op->rfd);
  GNUNET_free (op);
}

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

Referenced by GNUNET_ARM_request_service_start().

Here is the call graph for this function:

Here is the caller graph for this function: