src/arm/gnunet-arm.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2012, 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file arm/gnunet-arm.c
  23  * @brief arm for writing a tool
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_arm_service.h"
  28 #include "gnunet_constants.h"
  29 #include "gnunet_util_lib.h"
  30
  31 /**
  32  * Timeout for stopping services.  Long to give some services a real chance.
  33  */
  34 #define STOP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
  35
  36 /**
  37  * Timeout for stopping ARM.  Extra-long since ARM needs to stop everyone else.
  38  */
  39 #define STOP_TIMEOUT_ARM GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
  40
  41 /**
  42  * Timeout for starting services, very short because of the strange way start works
  43  * (by checking if running before starting, so really this time is always waited on
  44  * startup (annoying)).
  45  */
  46 #define START_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
  47
  48 /**
  49  * Timeout for listing all running services.
  50  */
  51 #define LIST_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
  52
  53 /**
  54  * Set if we are to shutdown all services (including ARM).
  55  */
  56 static int end;
  57
  58 /**
  59  * Set if we are to start default services (including ARM).
  60  */
  61 static int start;
  62
  63 /**
  64  * Set if we are to stop/start default services (including ARM).
  65  */
  66 static int restart;
  67
  68 /**
  69  * Set if we should delete configuration and temp directory on exit.
  70  */
  71 static int delete;
  72
  73 /**
  74  * Set if we should not print status messages.
  75  */
  76 static int quiet;
  77
  78 /**
  79  * Set if we should print a list of currently running services.
  80  */
  81 static int list;
  82
  83 /**
  84  * Set to the name of a service to start.
  85  */
  86 static char *init;
  87
  88 /**
  89  * Set to the name of a service to kill.
  90  */
  91 static char *term;
  92
  93 /**
  94  * Set to the name of the config file used.
  95  */
  96 static const char *config_file;
  97
  98 /**
  99  * Set to the directory where runtime files are stored.
 100  */
 101 static char *dir;
 102
 103 /**
 104  * Final status code.
 105  */
 106 static int ret;
 107
 108 /**
 109  * Connection with ARM.
 110  */
 111 static struct GNUNET_ARM_Handle *h;
 112
 113 /**
 114  * Monitor connection with ARM.
 115  */
 116 static struct GNUNET_ARM_MonitorHandle *m;
 117
 118 /**
 119  * Our configuration.
 120  */
 121 static struct GNUNET_CONFIGURATION_Handle *cfg;
 122
 123 /**
 124  * Processing stage that we are in.  Simple counter.
 125  */
 126 static unsigned int phase;
 127
 128 /**
 129  * User defined timestamp for completing operations.
 130  */
 131 static struct GNUNET_TIME_Relative timeout;
 132
 133 /**
 134  * Do we want to give our stdout to gnunet-service-arm?
 135  */
 136 static unsigned int no_stdout;
 137
 138 /**
 139  * Do we want to give our stderr to gnunet-service-arm?
 140  */
 141 static unsigned int no_stderr;
 142
 143
 144 /**
 145  * Attempts to delete configuration file and SERVICEHOME
 146  * on arm shutdown provided the end and delete options
 147  * were specified when gnunet-arm was run.
 148  */
 149 static void
 150 delete_files ()
 151 {
 152   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 153               "Will attempt to remove configuration file %s and service directory %s\n",
 154               config_file, dir);
 155
 156   if (UNLINK (config_file) != 0)
 157     {
 158       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 159                   _("Failed to remove configuration file %s\n"), config_file);
 160     }
 161
 162   if (GNUNET_DISK_directory_remove (dir) != GNUNET_OK)
 163     {
 164       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 165                   _("Failed to remove servicehome directory %s\n"), dir);
 166
 167     }
 168 }
 169
 170
 171 /**
 172  * Main continuation-passing-style loop.  Runs the various
 173  * jobs that we've been asked to do in order.
 174  *
 175  * @param cls closure, unused
 176  * @param tc context, unused
 177  */
 178 static void
 179 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 180 {
 181   GNUNET_ARM_disconnect_and_free (h);
 182   GNUNET_ARM_monitor_disconnect_and_free (m);
 183   h = NULL;
 184   m = NULL;
 185   if ((end == GNUNET_YES) && (delete == GNUNET_YES))
 186     delete_files ();
 187   GNUNET_CONFIGURATION_destroy (cfg);
 188   cfg = NULL;
 189 }
 190
 191
 192 static const char *
 193 req_string (enum GNUNET_ARM_RequestStatus rs)
 194 {
 195   switch (rs)
 196   {
 197   case GNUNET_ARM_REQUEST_SENT_OK:
 198     return _("Message was sent successfully");
 199   case GNUNET_ARM_REQUEST_CONFIGURATION_ERROR:
 200     return _("Misconfiguration (can't connect to the ARM service)");
 201   case GNUNET_ARM_REQUEST_DISCONNECTED:
 202     return _("We disconnected from ARM before we could send a request");
 203   case GNUNET_ARM_REQUEST_BUSY:
 204     return _("ARM API is busy");
 205   case GNUNET_ARM_REQUEST_TOO_LONG:
 206     return _("Request doesn't fit into a message");
 207   case GNUNET_ARM_REQUEST_TIMEOUT:
 208     return _("Request timed out");
 209   default:
 210     return _("Unknown request status");
 211   }
 212 }
 213
 214 static const char *
 215 ret_string (enum GNUNET_ARM_Result result)
 216 {
 217   switch (result)
 218   {
 219   case GNUNET_ARM_RESULT_STOPPED:
 220     return _("%s is stopped");
 221   case GNUNET_ARM_RESULT_STARTING:
 222     return _("%s is starting");
 223   case GNUNET_ARM_RESULT_IS_STARTING_ALREADY:
 224     return _("%s is starting already");
 225   case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY:
 226     return _("%s is stopping already");
 227   case GNUNET_ARM_RESULT_IS_STARTED_ALREADY:
 228     return _("%s is started already");
 229   case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY:
 230     return _("%s is stopped already");
 231   case GNUNET_ARM_RESULT_IS_NOT_KNOWN:
 232     return _("%s service is not known to ARM");
 233   case GNUNET_ARM_RESULT_START_FAILED:
 234     return _("%s service failed to start");
 235   case GNUNET_ARM_RESULT_IN_SHUTDOWN:
 236     return _("%s service can't be started because ARM is shutting down");
 237   default:
 238     return _("Unknown result code.");
 239   }
 240 }
 241
 242 static void action_loop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 243
 244 /**
 245  * Function called whenever we connect to or disconnect from ARM.
 246  *
 247  * @param cls closure
 248  * @param arm handle to the ARM connection
 249  * @param connected GNUNET_YES if connected, GNUNET_NO if disconnected,
 250  *                  GNUNET_SYSERR on error.
 251  * @param error GNUNET_YES if we encountered a permanent error, and there
 252  *              will be no re-connection.
 253  */
 254 static void
 255 conn_status (void *cls, struct GNUNET_ARM_Handle *arm, char connected)
 256 {
 257   if (GNUNET_SYSERR == connected)
 258   {
 259     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 260                 _("Fatal error initializing ARM API.\n"));
 261     GNUNET_SCHEDULER_shutdown ();
 262     return;
 263   }
 264 /*
 265   if (connected)
 266     GNUNET_SCHEDULER_add_now (action_loop, NULL);
 267 */
 268 }
 269
 270
 271 static void
 272 term_callback (void *cls, struct GNUNET_ARM_Handle *arm,
 273     enum GNUNET_ARM_RequestStatus rs, const char *service,
 274     enum GNUNET_ARM_Result result)
 275 {
 276   if (GNUNET_ARM_REQUEST_SENT_OK != rs)
 277   {
 278     char *msg;
 279     GNUNET_asprintf (&msg, _("Failed to send a request to kill the `%s' service: %%s\n"), term);
 280     FPRINTF (stdout, msg, req_string (rs));
 281     GNUNET_free (msg);
 282     GNUNET_SCHEDULER_shutdown ();
 283   }
 284   if ((GNUNET_ARM_RESULT_STOPPED == result) ||
 285       (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY == result))
 286   {
 287     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service %s shutdown successful\n", term);
 288     term = NULL;
 289     GNUNET_SCHEDULER_add_now (action_loop, NULL);
 290   }
 291   else
 292   {
 293     char *msg;
 294     GNUNET_asprintf (&msg, _("Failed to kill the `%s' service: %%s\n"), term);
 295     FPRINTF (stdout, msg, ret_string (result));
 296     GNUNET_free (msg);
 297     GNUNET_SCHEDULER_shutdown ();
 298   }
 299 }
 300
 301 static void
 302 end_callback (void *cls, struct GNUNET_ARM_Handle *arm,
 303     enum GNUNET_ARM_RequestStatus rs, const char *service,
 304     enum GNUNET_ARM_Result result)
 305 {
 306   if (GNUNET_ARM_REQUEST_SENT_OK != rs)
 307   {
 308     char *msg;
 309     GNUNET_asprintf (&msg, "%s", _("Failed to send a stop request to the ARM service: %s\n"));
 310     FPRINTF (stdout, msg, req_string (rs));
 311     GNUNET_free (msg);
 312     GNUNET_SCHEDULER_shutdown ();
 313   }
 314   if ((GNUNET_ARM_RESULT_STOPPING == result) ||
 315       (GNUNET_ARM_RESULT_STOPPED == result) ||
 316       (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY == result))
 317   {
 318     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM service shutdown successful\n");
 319     end = 0;
 320     if (restart)
 321     {
 322       restart = 0;
 323       start = 1;
 324       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initiating an ARM restart\n");
 325     }
 326     GNUNET_SCHEDULER_add_now (action_loop, NULL);
 327   }
 328   else
 329   {
 330     char *msg;
 331     GNUNET_asprintf (&msg, "%s", _("Failed to stop the ARM service: %s\n"));
 332     FPRINTF (stdout, msg, ret_string (result));
 333     GNUNET_free (msg);
 334     GNUNET_SCHEDULER_shutdown ();
 335   }
 336 }
 337
 338 static void
 339 start_callback (void *cls, struct GNUNET_ARM_Handle *arm,
 340     enum GNUNET_ARM_RequestStatus rs, const char *service,
 341     enum GNUNET_ARM_Result result)
 342 {
 343   if (GNUNET_ARM_REQUEST_SENT_OK != rs)
 344   {
 345     char *msg;
 346     GNUNET_asprintf (&msg, "%s", _("Failed to start the ARM service: %s\n"));
 347     FPRINTF (stdout, msg, req_string (rs));
 348     GNUNET_free (msg);
 349     GNUNET_SCHEDULER_shutdown ();
 350   }
 351   if ((GNUNET_ARM_RESULT_STARTING == result) ||
 352       (GNUNET_ARM_RESULT_IS_STARTED_ALREADY == result))
 353   {
 354     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM service [re]start successful\n");
 355     start = 0;
 356     GNUNET_SCHEDULER_add_now (action_loop, NULL);
 357   }
 358   else
 359   {
 360     char *msg;
 361     GNUNET_asprintf (&msg, "%s", _("Failed to start the ARM service: %s\n"));
 362     FPRINTF (stdout, msg, ret_string (result));
 363     GNUNET_free (msg);
 364     GNUNET_SCHEDULER_shutdown ();
 365   }
 366 }
 367
 368
 369 static void
 370 init_callback (void *cls, struct GNUNET_ARM_Handle *arm,
 371     enum GNUNET_ARM_RequestStatus rs, const char *service,
 372     enum GNUNET_ARM_Result result)
 373 {
 374   if (GNUNET_ARM_REQUEST_SENT_OK != rs)
 375   {
 376     char *msg;
 377     GNUNET_asprintf (&msg, _("Failed to send a request to start the `%s' service: %%s\n"), init);
 378     FPRINTF (stdout, msg, req_string (rs));
 379     GNUNET_free (msg);
 380     GNUNET_SCHEDULER_shutdown ();
 381   }
 382   if ((GNUNET_ARM_RESULT_STARTING == result) ||
 383       (GNUNET_ARM_RESULT_IS_STARTED_ALREADY == result))
 384   {
 385     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service %s [re]start successful\n", init);
 386     init = NULL;
 387     GNUNET_SCHEDULER_add_now (action_loop, NULL);
 388   }
 389   else
 390   {
 391     char *msg;
 392     GNUNET_asprintf (&msg, _("Failed to start the `%s' service: %%s\n"), init);
 393     FPRINTF (stdout, msg, ret_string (result));
 394     GNUNET_free (msg);
 395     GNUNET_SCHEDULER_shutdown ();
 396   }
 397 }
 398
 399
 400 static void
 401 list_callback (void *cls, struct GNUNET_ARM_Handle *arm,
 402     enum GNUNET_ARM_RequestStatus rs, unsigned int count,
 403     const char *const*list)
 404 {
 405   unsigned int i;
 406   if (GNUNET_ARM_REQUEST_SENT_OK != rs)
 407   {
 408     char *msg;
 409     GNUNET_asprintf (&msg, "%s", _("Failed to request a list of services: %s\n"));
 410     FPRINTF (stdout, msg, req_string (rs));
 411     GNUNET_free (msg);
 412     GNUNET_SCHEDULER_shutdown ();
 413   }
 414   if (NULL == list)
 415   {
 416     FPRINTF (stderr, "%s", _("Error communicating with ARM. ARM not running?\n"));
 417     return;
 418   }
 419   FPRINTF (stdout, "%s", _("Running services:\n"));
 420   for (i = 0; i < count; i++)
 421     FPRINTF (stdout, "%s\n", list[i]);
 422   GNUNET_SCHEDULER_add_now (action_loop, NULL);
 423 }
 424
 425
 426 /**
 427  * Main action loop.  Runs the various
 428  * jobs that we've been asked to do in order.
 429  *
 430  * @param cls closure, unused
 431  * @param tc context, unused
 432  */
 433 static void
 434 action_loop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 435 {
 436   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running requested actions\n");
 437   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 438     return;
 439   while (1)
 440   {
 441     switch (phase++)
 442     {
 443     case 0:
 444       if (NULL != term)
 445       {
 446         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Termination action\n");
 447         GNUNET_ARM_request_service_stop (h, term, (0 ==
 448             timeout.rel_value) ? STOP_TIMEOUT : timeout,
 449             term_callback, NULL);
 450         return;
 451       }
 452       break;
 453     case 1:
 454       if (end || restart)
 455       {
 456         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "End action\n");
 457         GNUNET_ARM_request_service_stop (h, "arm", (0 ==
 458             timeout.rel_value) ? STOP_TIMEOUT_ARM : timeout,
 459             end_callback, NULL);
 460         return;
 461       }
 462       break;
 463     case 2:
 464       if (start)
 465       {
 466         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start action\n");
 467         GNUNET_ARM_request_service_start (h, "arm",
 468             (no_stdout ? 0 : GNUNET_OS_INHERIT_STD_OUT) |
 469             (no_stderr ? 0 : GNUNET_OS_INHERIT_STD_ERR),
 470             (0 == timeout.rel_value) ? START_TIMEOUT: timeout,
 471             start_callback, NULL);
 472         return;
 473       }
 474       break;
 475     case 3:
 476       if (NULL != init)
 477       {
 478         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialization action\n");
 479         GNUNET_ARM_request_service_start (h, init, GNUNET_OS_INHERIT_STD_NONE,
 480             (0 == timeout.rel_value) ? STOP_TIMEOUT : timeout,
 481             init_callback, NULL);
 482         return;
 483       }
 484       break;
 485     case 4:
 486       if (list)
 487       {
 488         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 489                     "Going to list all running services controlled by ARM.\n");
 490
 491         GNUNET_ARM_request_service_list (h,
 492             (0 == timeout.rel_value) ? LIST_TIMEOUT : timeout,
 493             list_callback, &list);
 494         return;
 495       }
 496       /* Fall through */
 497     default:            /* last phase */
 498       GNUNET_SCHEDULER_shutdown ();
 499       return;
 500     }
 501   }
 502 }
 503
 504
 505 /**
 506  * Function called when a service starts or stops.
 507  *
 508  * @param cls closure
 509  * @param arm handle to the ARM connection
 510  * @param service service name
 511  * @param status status of the service
 512  */
 513 static void
 514 srv_status (void *cls, struct GNUNET_ARM_MonitorHandle *arm,
 515     const char *service, enum GNUNET_ARM_ServiceStatus status)
 516 {
 517   const char *msg;
 518   switch (status)
 519   {
 520   case GNUNET_ARM_SERVICE_MONITORING_STARTED:
 521     msg = _("Began monitoring ARM for service status changes\n");
 522     break;
 523   case GNUNET_ARM_SERVICE_STOPPED:
 524     msg = _("Stopped %s.\n");
 525     break;
 526   case GNUNET_ARM_SERVICE_STARTING:
 527     msg = _("Starting %s...\n");
 528     break;
 529   case GNUNET_ARM_SERVICE_STOPPING:
 530     msg = _("Stopping %s...\n");
 531     break;
 532   default:
 533     msg = NULL;
 534     break;
 535   }
 536   if (NULL != msg)
 537     FPRINTF (stderr, msg, service);
 538   else
 539     FPRINTF (stderr, _("Unknown status %u for service %s.\n"), status, service);
 540   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got service %s status %u\n", service, status);
 541 }
 542
 543
 544 /**
 545  * Main function that will be run by the scheduler.
 546  *
 547  * @param cls closure
 548  * @param args remaining command-line arguments
 549  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 550  * @param c configuration
 551  */
 552 static void
 553 run (void *cls, char *const *args, const char *cfgfile,
 554      const struct GNUNET_CONFIGURATION_Handle *c)
 555 {
 556   char *armconfig;
 557
 558   cfg = GNUNET_CONFIGURATION_dup (c);
 559   config_file = cfgfile;
 560   if (GNUNET_CONFIGURATION_get_value_string
 561       (cfg, "PATHS", "SERVICEHOME", &dir) != GNUNET_OK)
 562   {
 563     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
 564                                "PATHS", "SERVICEHOME");
 565     return;
 566     }
 567   if (NULL != cfgfile)
 568   {
 569     if (GNUNET_OK !=
 570         GNUNET_CONFIGURATION_get_value_filename (cfg, "arm", "CONFIG",
 571                                                  &armconfig))
 572     {
 573       GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG",
 574                                              cfgfile);
 575     }
 576     else
 577       GNUNET_free (armconfig);
 578   }
 579   h = GNUNET_ARM_connect (cfg, conn_status, NULL);
 580   if (NULL != h)
 581   {
 582     m = GNUNET_ARM_monitor (cfg, srv_status, NULL);
 583     if (NULL != m)
 584     {
 585       GNUNET_SCHEDULER_add_now (action_loop, NULL);
 586       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 587           shutdown_task, NULL);
 588     }
 589     else
 590     {
 591       GNUNET_ARM_disconnect_and_free (h);
 592       h = NULL;
 593     }
 594   }
 595 }
 596
 597
 598 /**
 599  * The main function to obtain arm from gnunetd.
 600  *
 601  * @param argc number of arguments from the command line
 602  * @param argv command line arguments
 603  * @return 0 ok, 1 on error
 604  */
 605 int
 606 main (int argc, char *const *argv)
 607 {
 608   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 609     {'e', "end", NULL, gettext_noop ("stop all GNUnet services"),
 610      GNUNET_NO, &GNUNET_GETOPT_set_one, &end},
 611     {'i', "init", "SERVICE", gettext_noop ("start a particular service"),
 612      GNUNET_YES, &GNUNET_GETOPT_set_string, &init},
 613     {'k', "kill", "SERVICE", gettext_noop ("stop a particular service"),
 614      GNUNET_YES, &GNUNET_GETOPT_set_string, &term},
 615     {'s', "start", NULL, gettext_noop ("start all GNUnet default services"),
 616      GNUNET_NO, &GNUNET_GETOPT_set_one, &start},
 617     {'r', "restart", NULL,
 618      gettext_noop ("stop and start all GNUnet default services"),
 619      GNUNET_NO, &GNUNET_GETOPT_set_one, &restart},
 620     {'d', "delete", NULL,
 621      gettext_noop ("delete config file and directory on exit"),
 622      GNUNET_NO, &GNUNET_GETOPT_set_one, &delete},
 623     {'q', "quiet", NULL, gettext_noop ("don't print status messages"),
 624      GNUNET_NO, &GNUNET_GETOPT_set_one, &quiet},
 625     {'T', "timeout", "MSECS",
 626      gettext_noop ("timeout in MSECS milliseconds for completing current operation"),
 627      GNUNET_YES, &GNUNET_GETOPT_set_relative_time, &timeout},
 628     {'I', "info", NULL, gettext_noop ("list currently running services"),
 629      GNUNET_NO, &GNUNET_GETOPT_set_one, &list},
 630     {'O', "no-stdout", NULL, gettext_noop ("don't let gnunet-service-arm inherit standard output"),
 631      GNUNET_NO, &GNUNET_GETOPT_set_one, &no_stdout},
 632     {'E', "no-stderr", NULL, gettext_noop ("don't let gnunet-service-arm inherit standard error"),
 633      GNUNET_NO, &GNUNET_GETOPT_set_one, &no_stderr},
 634     GNUNET_GETOPT_OPTION_END
 635   };
 636
 637   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 638     return 2;
 639
 640   if (GNUNET_OK ==
 641       GNUNET_PROGRAM_run (argc, argv, "gnunet-arm",
 642                           gettext_noop
 643                           ("Control services and the Automated Restart Manager (ARM)"),
 644                           options, &run, NULL))
 645     {
 646       GNUNET_free ((void *) argv);
 647       return ret;
 648     }
 649   GNUNET_free ((void*) argv);
 650   return 1;
 651 }
 652
 653 /* end of gnunet-arm.c */