/*
This file is part of GNUnet.
- (C) 2009, 2010, 2012, 2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2009, 2010, 2012, 2013 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
/**
* ID of the reconnect task (if any).
*/
- GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+ struct GNUNET_SCHEDULER_Task *reconnect_task;
/**
* Current delay we use for re-trying to connect to core.
unsigned char currently_down;
/**
- * GNUNET_YES if we're running a service test.
+ * #GNUNET_YES if we're running a service test.
*/
unsigned char service_test_is_active;
};
GNUNET_ARM_ServiceListCallback list_cont;
/**
- * Closure for 'result_cont' or 'list_cont'.
+ * Closure for @e result_cont' or @e list_cont'.
*/
void *cont_cls;
/**
* Task to run when request times out.
*/
- GNUNET_SCHEDULER_TaskIdentifier timeout_task_id;
+ struct GNUNET_SCHEDULER_Task * timeout_task_id;
/**
* Flags for passing std descriptors to ARM (when starting ARM).
* Connect to arm.
*
* @param h arm handle
- * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
*/
static int
reconnect_arm (struct GNUNET_ARM_Handle *h);
* Task scheduled to try to re-connect to arm.
*
* @param cls the 'struct GNUNET_ARM_Handle'
- * @param tc task context
*/
static void
-reconnect_arm_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect_arm_task (void *cls)
{
struct GNUNET_ARM_Handle *h = cls;
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ h->reconnect_task = NULL;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to ARM service after delay\n");
reconnect_arm (h);
}
h->client = NULL;
}
h->currently_down = GNUNET_YES;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
+ GNUNET_assert (NULL == h->reconnect_task);
h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_task, h);
+ GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
+ &reconnect_arm_task,
+ h);
/* Don't clear pending messages on disconnection, deliver them later
clear_pending_messages (h, GNUNET_ARM_REQUEST_DISCONNECTED);
GNUNET_assert (NULL == h->control_pending_head);
/**
* Handler for ARM replies.
*
- * @param cls our "struct GNUNET_ARM_Handle"
+ * @param cls our `struct GNUNET_ARM_Handle`
* @param msg the message received from the arm service
*/
static void
-client_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+client_notify_handler (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_ARM_Handle *h = cls;
const struct GNUNET_ARM_Message *arm_msg;
cm = find_cm_by_id (h, id);
if (NULL == cm)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Message with unknown id %llu\n", id);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Message with unknown id %llu\n",
+ id);
return;
}
fail = GNUNET_NO;
fail = GNUNET_YES;
break;
}
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
+ GNUNET_assert (NULL != cm->timeout_task_id);
GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
h->control_sent_tail, cm);
if (NULL != cm->list_cont)
cm->list_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, rcount,
list);
- GNUNET_free (list);
+ GNUNET_free_non_null (list);
break;
}
GNUNET_free (cm->msg);
/**
* Transmit the next message to the arm service.
*
- * @param cls closure with the 'struct GNUNET_ARM_Handle'
- * @param size number of bytes available in buf
+ * @param cls closure with the `struct GNUNET_ARM_Handle`
+ * @param size number of bytes available in @a buf
* @param buf where the callee should write the message
- * @return number of bytes written to buf
+ * @return number of bytes written to @a buf
*/
static size_t
transmit_arm_message (void *cls, size_t size, void *buf)
notify_connection = GNUNET_NO;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "transmit_arm_message is running with %p buffer of size %lu. ARM is known to be %s\n",
- buf, size, h->currently_down ? "unconnected" : "connected");
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
+ "transmit_arm_message is running with %p buffer of size %lu. ARM is known to be %s\n",
+ buf, size, h->currently_down ? "unconnected" : "connected");
+ GNUNET_assert (NULL == h->reconnect_task);
h->cth = NULL;
if ((GNUNET_YES == h->currently_down) && (NULL != buf))
{
}
if (NULL == (cm = h->control_pending_head))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue is empty, not sending anything\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Queue is empty, not sending anything\n");
msize = 0;
goto end;
}
*/
struct GNUNET_ARM_Handle *
GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
- GNUNET_ARM_ConnectionStatusCallback conn_status, void *cls)
+ GNUNET_ARM_ConnectionStatusCallback conn_status,
+ void *cls)
{
struct GNUNET_ARM_Handle *h;
- h = GNUNET_malloc (sizeof (struct GNUNET_ARM_Handle));
+ h = GNUNET_new (struct GNUNET_ARM_Handle);
h->cfg = GNUNET_CONFIGURATION_dup (cfg);
h->currently_down = GNUNET_YES;
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ h->reconnect_task = NULL;
h->conn_status = conn_status;
h->conn_status_cls = cls;
if (GNUNET_OK != reconnect_arm (h))
else
GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
h->control_sent_tail, cm);
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
+ GNUNET_assert (NULL != cm->timeout_task_id);
GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
if (NULL != cm->result_cont)
cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED,
GNUNET_CLIENT_disconnect (h->client);
h->client = NULL;
}
- if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
+ if (NULL != h->reconnect_task)
{
GNUNET_SCHEDULER_cancel (h->reconnect_task);
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ h->reconnect_task = NULL;
}
if (GNUNET_NO == h->service_test_is_active)
{
* Message timed out. Remove it from the queue.
*
* @param cls the message (struct ARMControlMessage *)
- * @param tc task context
*/
static void
-control_message_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+control_message_timeout (void *cls)
{
struct ARMControlMessage *cm = cls;
struct GNUNET_ARM_Message *arm_msg;
* it is not, start the ARM process.
*
* @param cls the context for the request that we will report on (struct ARMControlMessage *)
- * @param result GNUNET_YES if ARM is running
+ * @param result #GNUNET_YES if ARM is running
*/
static void
arm_service_report (void *cls,
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (
cm->h->cfg, "arm", "OPTIONS", &lopostfix))
lopostfix = GNUNET_strdup ("");
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (
- cm->h->cfg, "arm", "BINARY", &cbinary))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cm->h->cfg,
+ "arm",
+ "BINARY",
+ &cbinary))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, "arm", "BINARY");
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+ "arm",
+ "BINARY");
if (cm->result_cont)
cm->result_cont (cm->cont_cls,
GNUNET_ARM_REQUEST_SENT_OK, "arm",
GNUNET_free (lopostfix);
return;
}
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (
- cm->h->cfg, "arm", "CONFIG", &config))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (cm->h->cfg,
+ "arm", "CONFIG",
+ &config))
config = NULL;
binary = GNUNET_OS_get_libexec_binary_path (cbinary);
GNUNET_asprintf ("edbinary,
"\"%s\"",
binary);
GNUNET_free (cbinary);
- if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (
- cm->h->cfg, "TESTING", "WEAKRANDOM")) &&
- (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (
- cm->h->cfg, "TESTING", "WEAKRANDOM")) &&
- (GNUNET_NO == GNUNET_CONFIGURATION_have_value (
- cm->h->cfg, "TESTING", "HOSTFILE")))
+ if ( (GNUNET_YES ==
+ GNUNET_CONFIGURATION_have_value (cm->h->cfg,
+ "TESTING",
+ "WEAKRANDOM")) &&
+ (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno (cm->h->cfg,
+ "TESTING",
+ "WEAKRANDOM")) &&
+ (GNUNET_NO ==
+ GNUNET_CONFIGURATION_have_value (cm->h->cfg,
+ "TESTING",
+ "HOSTFILE")))
{
/* Means we are ONLY running locally */
/* we're clearly running a test, don't daemonize */
lopostfix, NULL);
else
proc = GNUNET_OS_start_process_s (GNUNET_NO, cm->std_inheritance,
- NULL, loprefix, quotedbinary, "-c", config,
+ NULL, loprefix, quotedbinary, "-c", config,
/* no daemonization! */
lopostfix, NULL);
}
if (NULL == proc)
{
if (cm->result_cont)
- cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, "arm",
- GNUNET_ARM_RESULT_START_FAILED);
+ cm->result_cont (cm->cont_cls,
+ GNUNET_ARM_REQUEST_SENT_OK, "arm",
+ GNUNET_ARM_RESULT_START_FAILED);
GNUNET_free (cm);
return;
}
if (cm->result_cont)
- cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, "arm",
- GNUNET_ARM_RESULT_STARTING);
+ cm->result_cont (cm->cont_cls,
+ GNUNET_ARM_REQUEST_SENT_OK, "arm",
+ GNUNET_ARM_RESULT_STARTING);
GNUNET_OS_process_destroy (proc);
h = cm->h;
GNUNET_free (cm);
h->control_pending_tail, cm);
cm->timeout_task_id =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
- (cm->timeout), &control_message_timeout, cm);
+ (cm->timeout),
+ &control_message_timeout, cm);
trigger_next_request (h, GNUNET_NO);
}
*/
if (GNUNET_NO == h->currently_down)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "ARM is already running\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "ARM is already running\n");
if (NULL != cont)
- cont (cont_cls, GNUNET_ARM_REQUEST_SENT_OK, "arm", GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
+ cont (cont_cls,
+ GNUNET_ARM_REQUEST_SENT_OK,
+ "arm",
+ GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
}
else if (GNUNET_NO == h->service_test_is_active)
{
GNUNET_CLIENT_disconnect (h->client);
h->client = NULL;
}
- if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
+ if (NULL != h->reconnect_task)
{
GNUNET_SCHEDULER_cancel (h->reconnect_task);
- h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+ h->reconnect_task = NULL;
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
cm->std_inheritance = std_inheritance;
memcpy (&cm[1], service_name, slen);
h->service_test_is_active = GNUNET_YES;
- GNUNET_CLIENT_service_test ("arm", h->cfg, timeout, &arm_service_report,
+ GNUNET_CLIENT_service_test ("arm",
+ h->cfg,
+ timeout,
+ &arm_service_report,
cm);
}
else
/* Service test is already running - tell user to chill out and try
* again later.
*/
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Service test is already in progress, we're busy\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Service test is already in progress, we're busy\n");
if (NULL != cont)
cont (cont_cls, GNUNET_ARM_REQUEST_BUSY, NULL, 0);
}
* Stopping arm itself will not invalidate its handle, and
* ARM API will try to restore connection to the ARM service,
* even if ARM connection was lost because you asked for ARM to be stopped.
- * Call GNUNET_ARM_disconnect_and_free () to free the handle and prevent
+ * Call #GNUNET_ARM_disconnect_and_free() to free the handle and prevent
* further connection attempts.
*
* @param h handle to ARM
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Requesting LIST from ARM service with timeout: %s\n",
GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_YES));
- cm = GNUNET_malloc (sizeof (struct ARMControlMessage));
+ cm = GNUNET_new (struct ARMControlMessage);
cm->h = h;
cm->list_cont = cont;
cm->cont_cls = cont_cls;
h->control_pending_tail, cm);
cm->timeout_task_id =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
- (cm->timeout), &control_message_timeout, cm);
+ (cm->timeout),
+ &control_message_timeout, cm);
trigger_next_request (h, GNUNET_NO);
}
projects / oweals / gnunet.git / blobdiff