X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Farm%2Fgnunet-arm.c;h=3b024ea93f183b41ebea20bb91df2f2ae6daece6;hb=4ab32191fbd53680ff5192fc7d53a21c67ae772d;hp=cfadbc87a1afb201c02ff27fcbf6883049611509;hpb=69af51a5a82110ce63aceca65dab5cae18c0fb9a;p=oweals%2Fgnunet.git diff --git a/src/arm/gnunet-arm.c b/src/arm/gnunet-arm.c index cfadbc87a..3b024ea93 100644 --- a/src/arm/gnunet-arm.c +++ b/src/arm/gnunet-arm.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2009, 2012, 2013 Christian Grothoff (and other contributing authors) + Copyright (C) 2009, 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 @@ -14,8 +14,8 @@ 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. */ /** @@ -28,28 +28,6 @@ #include "gnunet_constants.h" #include "gnunet_util_lib.h" -/** - * Timeout for stopping services. Long to give some services a real chance. - */ -#define STOP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1) - -/** - * Timeout for stopping ARM. Extra-long since ARM needs to stop everyone else. - */ -#define STOP_TIMEOUT_ARM GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2) - -/** - * Timeout for starting services, very short because of the strange way start works - * (by checking if running before starting, so really this time is always waited on - * startup (annoying)). - */ -#define START_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) - -/** - * Timeout for listing all running services. - */ -#define LIST_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2) - /** * Set if we are to shutdown all services (including ARM). */ @@ -75,6 +53,11 @@ static int delete; */ static int quiet; +/** + * Monitor ARM activity. + */ +static int monitor; + /** * Set if we should print a list of currently running services. */ @@ -127,6 +110,7 @@ static unsigned int phase; /** * User defined timestamp for completing operations. + * FIXME: to be implemented! */ static struct GNUNET_TIME_Relative timeout; @@ -140,10 +124,19 @@ static unsigned int no_stdout; */ static unsigned int no_stderr; +/** + * Handle for the task running the #action_loop(). + */ +static struct GNUNET_SCHEDULER_Task *al_task; + +/** + * Current operation. + */ +static struct GNUNET_ARM_Operation *op; /** - * Attempts to delete configuration file and SERVICEHOME - * on arm shutdown provided the end and delete options + * Attempts to delete configuration file and GNUNET_HOME + * on ARM shutdown provided the end and delete options * were specified when gnunet-arm was run. */ static void @@ -153,18 +146,19 @@ delete_files () "Will attempt to remove configuration file %s and service directory %s\n", config_file, dir); - if (UNLINK (config_file) != 0) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Failed to remove configuration file %s\n"), config_file); - } - - if (GNUNET_DISK_directory_remove (dir) != GNUNET_OK) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Failed to remove servicehome directory %s\n"), dir); + if (0 != UNLINK (config_file)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Failed to remove configuration file %s\n"), + config_file); + } + if (GNUNET_OK != GNUNET_DISK_directory_remove (dir)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Failed to remove servicehome directory %s\n"), + dir); - } + } } @@ -173,17 +167,32 @@ delete_files () * jobs that we've been asked to do in order. * * @param cls closure, unused - * @param tc context, unused */ static void -shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +shutdown_task (void *cls) { - GNUNET_ARM_disconnect_and_free (h); - GNUNET_ARM_monitor_disconnect_and_free (m); - h = NULL; - m = NULL; - if ((end == GNUNET_YES) && (delete == GNUNET_YES)) - delete_files (); + if (NULL != al_task) + { + GNUNET_SCHEDULER_cancel (al_task); + al_task = NULL; + } + if (NULL != op) + { + GNUNET_ARM_operation_cancel (op); + op = NULL; + } + if (NULL != h) + { + GNUNET_ARM_disconnect (h); + h = NULL; + } + if (NULL != m) + { + GNUNET_ARM_monitor_stop (m); + m = NULL; + } + if ((GNUNET_YES == end) && (GNUNET_YES == delete)) + delete_files (); GNUNET_CONFIGURATION_destroy (cfg); cfg = NULL; } @@ -203,13 +212,11 @@ req_string (enum GNUNET_ARM_RequestStatus rs) case GNUNET_ARM_REQUEST_SENT_OK: return _("Message was sent successfully"); case GNUNET_ARM_REQUEST_CONFIGURATION_ERROR: - return _("Misconfiguration (can't connect to the ARM service)"); + return _("Misconfiguration (can not connect to the ARM service)"); case GNUNET_ARM_REQUEST_DISCONNECTED: return _("We disconnected from ARM before we could send a request"); case GNUNET_ARM_REQUEST_BUSY: return _("ARM API is busy"); - case GNUNET_ARM_REQUEST_TOO_LONG: - return _("Request doesn't fit into a message"); case GNUNET_ARM_REQUEST_TIMEOUT: return _("Request timed out"); } @@ -247,206 +254,302 @@ ret_string (enum GNUNET_ARM_Result result) case GNUNET_ARM_RESULT_START_FAILED: return _("%s service failed to start"); case GNUNET_ARM_RESULT_IN_SHUTDOWN: - return _("%s service can't be started because ARM is shutting down"); + return _("%s service cannot be started because ARM is shutting down"); } return _("%.s Unknown result code."); } -static void action_loop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); + +/** + * Main task that runs our various operations in order. + * + * @param cls closure + */ +static void +action_loop (void *cls); + /** * Function called whenever we connect to or disconnect from ARM. + * Termiantes the process if we fail to connect to the service on + * our first attempt. * * @param cls closure - * @param arm handle to the ARM connection - * @param connected GNUNET_YES if connected, GNUNET_NO if disconnected, - * GNUNET_SYSERR on error. + * @param connected #GNUNET_YES if connected, #GNUNET_NO if disconnected, + * #GNUNET_SYSERR on error. */ static void -conn_status (void *cls, struct GNUNET_ARM_Handle *arm, +conn_status (void *cls, int connected) { - if (GNUNET_SYSERR == connected) + static int once; + + if ( (GNUNET_SYSERR == connected) && + (0 == once) ) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fatal error initializing ARM API.\n")); GNUNET_SCHEDULER_shutdown (); return; } -/* - if (connected) - GNUNET_SCHEDULER_add_now (action_loop, NULL); -*/ + once = 1; } +/** + * We have requested ARM to be started, this function + * is called with the result of the operation. Informs the + * use of the result; on success, we continue with the event + * loop, on failure we terminate the process. + * + * @param cls closure unused + * @param rs what happened to our request + * @param result if the request was processed, this is the result + * according to ARM + */ static void -term_callback (void *cls, struct GNUNET_ARM_Handle *arm, - enum GNUNET_ARM_RequestStatus rs, const char *service, - enum GNUNET_ARM_Result result) +start_callback (void *cls, + enum GNUNET_ARM_RequestStatus rs, + enum GNUNET_ARM_Result result) { + char *msg; + + op = NULL; if (GNUNET_ARM_REQUEST_SENT_OK != rs) { - char *msg; - GNUNET_asprintf (&msg, _("Failed to send a request to kill the `%s' service: %%s\n"), term); + GNUNET_asprintf (&msg, "%s", _("Failed to start the ARM service: %s\n")); FPRINTF (stdout, msg, req_string (rs)); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); + return; } - if ((GNUNET_ARM_RESULT_STOPPED == result) || - (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY == result)) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service %s shutdown successful\n", term); - term = NULL; - GNUNET_SCHEDULER_add_now (action_loop, NULL); - } - else + if ( (GNUNET_ARM_RESULT_STARTING != result) && + (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result) ) { - char *msg; - GNUNET_asprintf (&msg, _("Failed to kill the `%s' service: %%s\n"), term); + GNUNET_asprintf (&msg, "%s", _("Failed to start the ARM service: %s\n")); FPRINTF (stdout, msg, ret_string (result)); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); + return; } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ARM service [re]start successful\n"); + start = 0; + al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); } + +/** + * We have requested ARM to be stopped, this function + * is called with the result of the operation. Informs the + * use of the result; on success, we continue with the event + * loop, on failure we terminate the process. + * + * @param cls closure unused + * @param rs what happened to our request + * @param result if the request was processed, this is the result + * according to ARM + */ static void -end_callback (void *cls, struct GNUNET_ARM_Handle *arm, - enum GNUNET_ARM_RequestStatus rs, const char *service, - enum GNUNET_ARM_Result result) +stop_callback (void *cls, + enum GNUNET_ARM_RequestStatus rs, + enum GNUNET_ARM_Result result) { + char *msg; + + op = NULL; if (GNUNET_ARM_REQUEST_SENT_OK != rs) { - char *msg; - GNUNET_asprintf (&msg, "%s", _("Failed to send a stop request to the ARM service: %s\n")); + GNUNET_asprintf (&msg, "%s", + _("Failed to send a stop request to the ARM service: %s\n")); FPRINTF (stdout, msg, req_string (rs)); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); + return; } - if ((GNUNET_ARM_RESULT_STOPPING == result) || - (GNUNET_ARM_RESULT_STOPPED == result) || - (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY == result)) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM service shutdown successful\n"); - end = 0; - if (restart) - { - restart = 0; - start = 1; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initiating an ARM restart\n"); - } - GNUNET_SCHEDULER_add_now (action_loop, NULL); - } - else + if ((GNUNET_ARM_RESULT_STOPPING != result) && + (GNUNET_ARM_RESULT_STOPPED != result) && + (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) { - char *msg; - GNUNET_asprintf (&msg, "%s", _("Failed to stop the ARM service: %s\n")); + GNUNET_asprintf (&msg, "%s", + _("Failed to stop the ARM service: %s\n")); FPRINTF (stdout, msg, ret_string (result)); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ARM service shutdown successful\n"); + end = 0; + if (restart) + { + restart = 0; + start = 1; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Initiating an ARM restart\n"); } + al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); } + +/** + * We have requested a service to be started, this function + * is called with the result of the operation. Informs the + * use of the result; on success, we continue with the event + * loop, on failure we terminate the process. + * + * @param cls closure unused + * @param rs what happened to our request + * @param result if the request was processed, this is the result + * according to ARM + */ static void -start_callback (void *cls, struct GNUNET_ARM_Handle *arm, - enum GNUNET_ARM_RequestStatus rs, const char *service, - enum GNUNET_ARM_Result result) +init_callback (void *cls, + enum GNUNET_ARM_RequestStatus rs, + enum GNUNET_ARM_Result result) { char *msg; + op = NULL; if (GNUNET_ARM_REQUEST_SENT_OK != rs) { - GNUNET_asprintf (&msg, "%s", _("Failed to start the ARM service: %s\n")); + GNUNET_asprintf (&msg, + _("Failed to send a request to start the `%s' service: %%s\n"), + init); FPRINTF (stdout, msg, req_string (rs)); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); return; } - if (! ((GNUNET_ARM_RESULT_STARTING == result) || - (GNUNET_ARM_RESULT_IS_STARTED_ALREADY == result)) ) + if ((GNUNET_ARM_RESULT_STARTING != result) && + (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) { - GNUNET_asprintf (&msg, "%s", _("Failed to start the ARM service: %s\n")); - FPRINTF (stdout, msg, ret_string (result)); + GNUNET_asprintf (&msg, + _("Failed to start the `%s' service: %s\n"), + init, + ret_string (result)); + FPRINTF (stdout, "%s", msg); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM service [re]start successful\n"); - start = 0; - GNUNET_SCHEDULER_add_now (action_loop, NULL); - return; + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Service %s [re]started successfully\n", + init); + GNUNET_free (init); + init = NULL; + al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); } +/** + * We have requested a service to be stopped, this function + * is called with the result of the operation. Informs the + * use of the result; on success, we continue with the event + * loop, on failure we terminate the process. + * + * @param cls closure unused + * @param rs what happened to our request + * @param result if the request was processed, this is the result + * according to ARM + */ static void -init_callback (void *cls, struct GNUNET_ARM_Handle *arm, - enum GNUNET_ARM_RequestStatus rs, const char *service, - enum GNUNET_ARM_Result result) +term_callback (void *cls, + enum GNUNET_ARM_RequestStatus rs, + enum GNUNET_ARM_Result result) { + char *msg; + + op = NULL; if (GNUNET_ARM_REQUEST_SENT_OK != rs) { - char *msg; - GNUNET_asprintf (&msg, _("Failed to send a request to start the `%s' service: %%s\n"), init); + GNUNET_asprintf (&msg, + _("Failed to send a request to kill the `%s' service: %%s\n"), + term); FPRINTF (stdout, msg, req_string (rs)); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); + return; } - if ((GNUNET_ARM_RESULT_STARTING == result) || - (GNUNET_ARM_RESULT_IS_STARTED_ALREADY == result)) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service %s [re]start successful\n", init); - init = NULL; - GNUNET_SCHEDULER_add_now (action_loop, NULL); - } - else + if ((GNUNET_ARM_RESULT_STOPPED != result) && + (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) { - char *msg; - GNUNET_asprintf (&msg, _("Failed to start the `%s' service: %%s\n"), init); - FPRINTF (stdout, msg, ret_string (result)); + GNUNET_asprintf (&msg, + _("Failed to kill the `%s' service: %s\n"), + term, ret_string (result)); + FPRINTF (stdout, "%s", msg); GNUNET_free (msg); GNUNET_SCHEDULER_shutdown (); + return; } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Service %s stopped successfully\n", + term); + GNUNET_free (term); + term = NULL; + al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); } +/** + * Function called with the list of running services. Prints + * the list to stdout, then starts the event loop again. + * Prints an error message and terminates the process on errors. + * + * @param cls closure (unused) + * @param rs request status (success, failure, etc.) + * @param count number of services in the list + * @param list list of services that are running + */ static void -list_callback (void *cls, struct GNUNET_ARM_Handle *arm, - enum GNUNET_ARM_RequestStatus rs, unsigned int count, - const char *const*list) +list_callback (void *cls, + enum GNUNET_ARM_RequestStatus rs, + unsigned int count, + const char *const*list) { unsigned int i; + + op = NULL; if (GNUNET_ARM_REQUEST_SENT_OK != rs) { char *msg; - GNUNET_asprintf (&msg, "%s", _("Failed to request a list of services: %s\n")); + + GNUNET_asprintf (&msg, "%s", + _("Failed to request a list of services: %s\n")); FPRINTF (stdout, msg, req_string (rs)); GNUNET_free (msg); + ret = 3; GNUNET_SCHEDULER_shutdown (); } if (NULL == list) { - FPRINTF (stderr, "%s", _("Error communicating with ARM. ARM not running?\n")); + FPRINTF (stderr, "%s", + _("Error communicating with ARM. ARM not running?\n")); + GNUNET_SCHEDULER_shutdown (); + ret = 3; return; } - FPRINTF (stdout, "%s", _("Running services:\n")); + if (! quiet) + FPRINTF (stdout, "%s", _("Running services:\n")); for (i = 0; i < count; i++) FPRINTF (stdout, "%s\n", list[i]); - GNUNET_SCHEDULER_add_now (action_loop, NULL); + al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); } /** - * Main action loop. Runs the various - * jobs that we've been asked to do in order. + * Main action loop. Runs the various jobs that we've been asked to + * do, in order. * * @param cls closure, unused - * @param tc context, unused */ static void -action_loop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) +action_loop (void *cls) { - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running requested actions\n"); + al_task = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Running requested actions\n"); while (1) { switch (phase++) @@ -454,57 +557,73 @@ action_loop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) case 0: if (NULL != term) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Termination action\n"); - GNUNET_ARM_request_service_stop (h, term, (0 == - timeout.rel_value) ? STOP_TIMEOUT : timeout, - term_callback, NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Termination action\n"); + op = GNUNET_ARM_request_service_stop (h, + term, + &term_callback, + NULL); return; } break; case 1: if (end || restart) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "End action\n"); - GNUNET_ARM_request_service_stop (h, "arm", (0 == - timeout.rel_value) ? STOP_TIMEOUT_ARM : timeout, - end_callback, NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "End action\n"); + op = GNUNET_ARM_request_service_stop (h, + "arm", + &stop_callback, + NULL); return; } break; case 2: if (start) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start action\n"); - GNUNET_ARM_request_service_start (h, "arm", - (no_stdout ? 0 : GNUNET_OS_INHERIT_STD_OUT) | - (no_stderr ? 0 : GNUNET_OS_INHERIT_STD_ERR), - (0 == timeout.rel_value) ? START_TIMEOUT: timeout, - start_callback, NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Start action\n"); + op = GNUNET_ARM_request_service_start (h, "arm", + (no_stdout ? 0 : GNUNET_OS_INHERIT_STD_OUT) | + (no_stderr ? 0 : GNUNET_OS_INHERIT_STD_ERR), + &start_callback, + NULL); return; } break; case 3: if (NULL != init) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialization action\n"); - GNUNET_ARM_request_service_start (h, init, GNUNET_OS_INHERIT_STD_NONE, - (0 == timeout.rel_value) ? STOP_TIMEOUT : timeout, - init_callback, NULL); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Initialization action\n"); + op = GNUNET_ARM_request_service_start (h, init, + GNUNET_OS_INHERIT_STD_NONE, + &init_callback, + NULL); return; } break; case 4: - if (list) + if (list) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Going to list all running services controlled by ARM.\n"); - - GNUNET_ARM_request_service_list (h, - (0 == timeout.rel_value) ? LIST_TIMEOUT : timeout, - list_callback, &list); + op = GNUNET_ARM_request_service_list (h, + &list_callback, + &list); return; } - /* Fall through */ + break; + case 5: + if (monitor) + { + if (! quiet) + fprintf (stderr, + _("Now only monitoring, press CTRL-C to stop.\n")); + quiet = 0; /* does not make sense to stay quiet in monitor mode at this time */ + return; /* done with tasks, just monitor */ + } + break; default: /* last phase */ GNUNET_SCHEDULER_shutdown (); return; @@ -517,20 +636,20 @@ action_loop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * Function called when a service starts or stops. * * @param cls closure - * @param arm handle to the ARM connection * @param service service name * @param status status of the service */ static void -srv_status (void *cls, struct GNUNET_ARM_MonitorHandle *arm, - const char *service, enum GNUNET_ARM_ServiceStatus status) +srv_status (void *cls, + const char *service, + enum GNUNET_ARM_ServiceStatus status) { const char *msg; + switch (status) { case GNUNET_ARM_SERVICE_MONITORING_STARTED: - msg = _("Began monitoring ARM for service status changes\n"); - break; + return; /* this should be done silently */ case GNUNET_ARM_SERVICE_STOPPED: msg = _("Stopped %s.\n"); break; @@ -544,11 +663,22 @@ srv_status (void *cls, struct GNUNET_ARM_MonitorHandle *arm, msg = NULL; break; } - if (NULL != msg) - FPRINTF (stderr, msg, service); - else - FPRINTF (stderr, _("Unknown status %u for service %s.\n"), status, service); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got service %s status %u\n", service, status); + if (! quiet) + { + if (NULL != msg) + FPRINTF (stderr, + msg, + service); + else + FPRINTF (stderr, + _("Unknown status %u for service %s.\n"), + status, + service); + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got service %s status %d\n", + service, (int) + status); } @@ -561,48 +691,54 @@ srv_status (void *cls, struct GNUNET_ARM_MonitorHandle *arm, * @param c configuration */ static void -run (void *cls, char *const *args, const char *cfgfile, +run (void *cls, + char *const *args, + const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c) { char *armconfig; cfg = GNUNET_CONFIGURATION_dup (c); config_file = cfgfile; - if (GNUNET_CONFIGURATION_get_value_string - (cfg, "PATHS", "SERVICEHOME", &dir) != GNUNET_OK) + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (cfg, + "PATHS", + "GNUNET_HOME", + &dir)) { GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, - "PATHS", "SERVICEHOME"); + "PATHS", + "GNUNET_HOME"); return; - } + } if (NULL != cfgfile) { if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename (cfg, "arm", "CONFIG", + GNUNET_CONFIGURATION_get_value_filename (cfg, + "arm", + "CONFIG", &armconfig)) { - GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG", + GNUNET_CONFIGURATION_set_value_string (cfg, + "arm", + "CONFIG", cfgfile); } else GNUNET_free (armconfig); } - h = GNUNET_ARM_connect (cfg, &conn_status, NULL); - if (NULL != h) - { - m = GNUNET_ARM_monitor (cfg, &srv_status, NULL); - if (NULL != m) - { - GNUNET_SCHEDULER_add_now (&action_loop, NULL); - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, - shutdown_task, NULL); - } - else - { - GNUNET_ARM_disconnect_and_free (h); - h = NULL; - } - } + if (NULL == (h = GNUNET_ARM_connect (cfg, + &conn_status, + NULL))) + return; + if (monitor) + m = GNUNET_ARM_monitor_start (cfg, + &srv_status, + NULL); + al_task = GNUNET_SCHEDULER_add_now (&action_loop, + NULL); + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, + NULL); } @@ -631,10 +767,13 @@ main (int argc, char *const *argv) {'d', "delete", NULL, gettext_noop ("delete config file and directory on exit"), GNUNET_NO, &GNUNET_GETOPT_set_one, &delete}, + {'m', "monitor", NULL, + gettext_noop ("monitor ARM activities"), + GNUNET_NO, &GNUNET_GETOPT_set_one, &monitor}, {'q', "quiet", NULL, gettext_noop ("don't print status messages"), GNUNET_NO, &GNUNET_GETOPT_set_one, &quiet}, - {'T', "timeout", "MSECS", - gettext_noop ("timeout in MSECS milliseconds for completing current operation"), + {'T', "timeout", "DELAY", + gettext_noop ("exit with error status if operation does not finish after DELAY"), GNUNET_YES, &GNUNET_GETOPT_set_relative_time, &timeout}, {'I', "info", NULL, gettext_noop ("list currently running services"), GNUNET_NO, &GNUNET_GETOPT_set_one, &list}, @@ -645,7 +784,8 @@ main (int argc, char *const *argv) GNUNET_GETOPT_OPTION_END }; - if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) + if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, + &argc, &argv)) return 2; if (GNUNET_OK ==