src/arm/arm_api.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010, 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/arm_api.c
  23  * @brief API for accessing the ARM service
  24  * @author Christian Grothoff, LRN
  25  */
  26 #include "platform.h"
  27 #include "gnunet_arm_service.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_protocols.h"
  30 #include "arm.h"
  31
  32 #define LOG(kind,...) GNUNET_log_from (kind, "arm-api",__VA_ARGS__)
  33
  34 /**
  35  * Handle for interacting with ARM.
  36  */
  37 struct GNUNET_ARM_Handle
  38 {
  39   /**
  40    * Our control connection to the ARM service.
  41    */
  42   struct GNUNET_CLIENT_Connection *client;
  43
  44   /**
  45    * The configuration that we are using.
  46    */
  47   struct GNUNET_CONFIGURATION_Handle *cfg;
  48
  49   /**
  50    * Handle for our current transmission request.
  51    */
  52   struct GNUNET_CLIENT_TransmitHandle *cth;
  53
  54   /**
  55    * Head of doubly-linked list of pending requests.
  56    */
  57   struct ARMControlMessage *control_pending_head;
  58
  59   /**
  60    * Tail of doubly-linked list of pending requests.
  61    */
  62   struct ARMControlMessage *control_pending_tail;
  63
  64   /**
  65    * Head of doubly-linked list of sent requests.
  66    */
  67   struct ARMControlMessage *control_sent_head;
  68
  69   /**
  70    * Tail of doubly-linked list of sent requests.
  71    */
  72   struct ARMControlMessage *control_sent_tail;
  73
  74   /**
  75    * ID of the reconnect task (if any).
  76    */
  77   GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
  78
  79   /**
  80    * Current delay we use for re-trying to connect to core.
  81    */
  82   struct GNUNET_TIME_Relative retry_backoff;
  83
  84   /**
  85    * Callback to invoke on connection/disconnection.
  86    */
  87   GNUNET_ARM_ConnectionStatusCallback conn_status;
  88
  89   /**
  90    * Closure for conn_status.
  91    */
  92   void *conn_status_cls;
  93
  94   /**
  95    * Counter for request identifiers
  96    */
  97   uint64_t request_id_counter;
  98
  99   /**
 100    * Are we currently disconnected and hence unable to send?
 101    */
 102   unsigned char currently_down;
 103
 104   /**
 105    * GNUNET_YES if we're running a service test.
 106    */
 107   unsigned char service_test_is_active;
 108 };
 109
 110
 111 /**
 112  * Entry in a doubly-linked list of control messages to be transmitted
 113  * to the arm service.
 114  *
 115  * The actual message is allocated at the end of this struct.
 116  */
 117 struct ARMControlMessage
 118 {
 119   /**
 120    * This is a doubly-linked list.
 121    */
 122   struct ARMControlMessage *next;
 123
 124   /**
 125    * This is a doubly-linked list.
 126    */
 127   struct ARMControlMessage *prev;
 128
 129   /**
 130    * ARM handle.
 131    */
 132   struct GNUNET_ARM_Handle *h;
 133
 134   /**
 135    * Message to send.
 136    */
 137   struct GNUNET_ARM_Message *msg;
 138
 139   /**
 140    * Callback for service state change requests.
 141    */
 142   GNUNET_ARM_ResultCallback result_cont;
 143
 144   /**
 145    * Callback for service list requests.
 146    */
 147   GNUNET_ARM_ServiceListCallback list_cont;
 148
 149   /**
 150    * Closure for 'result_cont' or 'list_cont'.
 151    */
 152   void *cont_cls;
 153
 154   /**
 155    * Timeout for the operation.
 156    */
 157   struct GNUNET_TIME_Absolute timeout;
 158
 159   /**
 160    * Flags for passing std descriptors to ARM (when starting ARM).
 161    */
 162   enum GNUNET_OS_InheritStdioFlags std_inheritance;
 163
 164   /**
 165    * Task to run when request times out.
 166    */
 167   GNUNET_SCHEDULER_TaskIdentifier timeout_task_id;
 168
 169   /**
 170    * Type of the request expressed as a message type (start, stop or list).
 171    */
 172   uint16_t type;
 173 };
 174
 175 static void
 176 client_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg);
 177
 178 static int
 179 reconnect_arm (struct GNUNET_ARM_Handle *h);
 180
 181 static void
 182 trigger_next_request (struct GNUNET_ARM_Handle *h, int ignore_currently_down);
 183
 184
 185 /**
 186  * Task scheduled to try to re-connect to arm.
 187  *
 188  * @param cls the 'struct GNUNET_ARM_Handle'
 189  * @param tc task context
 190  */
 191 static void
 192 reconnect_arm_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 193 {
 194   struct GNUNET_ARM_Handle *h = cls;
 195
 196   h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 197   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to ARM service after delay\n");
 198   reconnect_arm (h);
 199 }
 200
 201
 202 /**
 203  * Close down any existing connection to the ARM service and
 204  * try re-establishing it later.
 205  *
 206  * @param h our handle
 207  */
 208 static void
 209 reconnect_arm_later (struct GNUNET_ARM_Handle *h)
 210 {
 211   if (GNUNET_NO != h->currently_down)
 212     return;
 213   if (NULL != h->cth)
 214   {
 215     GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
 216     h->cth = NULL;
 217   }
 218   if (NULL != h->client)
 219   {
 220     GNUNET_CLIENT_disconnect (h->client);
 221     h->client = NULL;
 222   }
 223   h->currently_down = GNUNET_YES;
 224   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
 225   h->reconnect_task =
 226       GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_task, h);
 227   /* Don't clear pending messages on disconnection, deliver them later
 228   clear_pending_messages (h, GNUNET_ARM_REQUEST_DISCONNECTED);
 229   GNUNET_assert (NULL == h->control_pending_head);
 230   */
 231   h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff);
 232   if (NULL != h->conn_status)
 233     h->conn_status (h->conn_status_cls, GNUNET_NO);
 234 }
 235
 236 /**
 237  * Transmit the next message to the arm service.
 238  *
 239  * @param cls closure with the 'struct GNUNET_ARM_Handle'
 240  * @param size number of bytes available in buf
 241  * @param buf where the callee should write the message
 242  * @return number of bytes written to buf
 243  */
 244 static size_t
 245 transmit_arm_message (void *cls, size_t size, void *buf)
 246 {
 247   struct GNUNET_ARM_Handle *h = cls;
 248   struct ARMControlMessage *cm;
 249   struct GNUNET_ARM_Message *arm_msg;
 250   uint64_t request_id;
 251   int notify_connection;
 252   uint16_t msize;
 253
 254   notify_connection = GNUNET_NO;
 255   LOG (GNUNET_ERROR_TYPE_DEBUG,
 256       "transmit_arm_message is running with %p buffer of size %lu. ARM is known to be %s\n",
 257       buf, size, h->currently_down ? "unconnected" : "connected");
 258   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
 259   h->cth = NULL;
 260   if ((GNUNET_YES == h->currently_down) && (NULL != buf))
 261   {
 262     h->currently_down = GNUNET_NO;
 263     notify_connection = GNUNET_YES;
 264     h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
 265     GNUNET_CLIENT_receive (h->client, &client_notify_handler, h,
 266                            GNUNET_TIME_UNIT_FOREVER_REL);
 267   }
 268   if (NULL == buf)
 269   {
 270     LOG (GNUNET_ERROR_TYPE_DEBUG,
 271          "Transmission failed, initiating reconnect\n");
 272     reconnect_arm_later (h);
 273     return 0;
 274   }
 275   if (NULL == (cm = h->control_pending_head))
 276   {
 277     LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue is empty, not sending anything\n");
 278     msize = 0;
 279     goto end;
 280   }
 281   GNUNET_assert (NULL != cm->msg);
 282   msize = ntohs (cm->msg->header.size);
 283   if (size < msize)
 284   {
 285     LOG (GNUNET_ERROR_TYPE_DEBUG,
 286         "Request is too big (%u < %u), not sending it\n", size, msize);
 287     trigger_next_request (h, GNUNET_NO);
 288     msize = 0;
 289     goto end;
 290   }
 291   arm_msg = cm->msg;
 292   if (0 == h->request_id_counter)
 293     h->request_id_counter++;
 294   request_id = h->request_id_counter++;
 295   LOG (GNUNET_ERROR_TYPE_DEBUG,
 296        "Transmitting control message with %u bytes of type %u to arm with id %llu\n",
 297        (unsigned int) msize, (unsigned int) ntohs (cm->msg->header.type), request_id);
 298   arm_msg->request_id = GNUNET_htonll (request_id);
 299   memcpy (buf, cm->msg, msize);
 300   /* Otherwise we won't be able to find it later! */
 301   arm_msg->request_id = request_id;
 302   GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
 303                                h->control_pending_tail, cm);
 304   GNUNET_CONTAINER_DLL_insert_tail (h->control_sent_head,
 305                                     h->control_sent_tail, cm);
 306   /* Don't free msg, keep it around (kind of wasteful, but then we don't
 307    * really have many messages to handle, and it'll be freed when it times
 308    * out anyway.
 309    */
 310   trigger_next_request (h, GNUNET_NO);
 311
 312  end:
 313   if ((GNUNET_YES == notify_connection) && (NULL != h->conn_status))
 314     h->conn_status (h->conn_status_cls, GNUNET_YES);
 315   return msize;
 316 }
 317
 318
 319 /**
 320  * Check the list of pending requests, send the next
 321  * one to the arm.
 322  *
 323  * @param h arm handle
 324  * @param ignore_currently_down transmit message even if not initialized?
 325  */
 326 static void
 327 trigger_next_request (struct GNUNET_ARM_Handle *h, int ignore_currently_down)
 328 {
 329   uint16_t msize;
 330
 331   msize = sizeof (struct GNUNET_MessageHeader);
 332   if ((GNUNET_YES == h->currently_down) && (ignore_currently_down == GNUNET_NO))
 333   {
 334     LOG (GNUNET_ERROR_TYPE_DEBUG,
 335          "ARM connection down, not processing queue\n");
 336     return;
 337   }
 338   if (NULL != h->cth)
 339   {
 340     LOG (GNUNET_ERROR_TYPE_DEBUG, "Request pending, not processing queue\n");
 341     return;
 342   }
 343   if (NULL != h->control_pending_head)
 344     msize =
 345         ntohs (((struct GNUNET_MessageHeader *) &h->
 346                 control_pending_head[1])->size);
 347   else if (GNUNET_NO == ignore_currently_down)
 348   {
 349     LOG (GNUNET_ERROR_TYPE_DEBUG,
 350          "Request queue empty, not processing queue\n");
 351     return;                     /* no pending message */
 352   }
 353   h->cth =
 354       GNUNET_CLIENT_notify_transmit_ready (h->client, msize,
 355                                            GNUNET_TIME_UNIT_FOREVER_REL,
 356                                            GNUNET_NO, &transmit_arm_message, h);
 357 }
 358
 359
 360 /**
 361  * Connect to arm.
 362  *
 363  * @param h arm handle
 364  */
 365 static int
 366 reconnect_arm (struct GNUNET_ARM_Handle *h)
 367 {
 368   GNUNET_assert (NULL == h->client);
 369   GNUNET_assert (GNUNET_YES == h->currently_down);
 370   h->client = GNUNET_CLIENT_connect ("arm", h->cfg);
 371   if (NULL == h->client)
 372   {
 373     LOG (GNUNET_ERROR_TYPE_DEBUG,
 374            "arm_api, GNUNET_CLIENT_connect returned NULL\n");
 375     if (NULL != h->conn_status)
 376       h->conn_status (h->conn_status_cls, GNUNET_SYSERR);
 377     return GNUNET_SYSERR;
 378   }
 379   LOG (GNUNET_ERROR_TYPE_DEBUG,
 380          "arm_api, GNUNET_CLIENT_connect returned non-NULL\n");
 381   trigger_next_request (h, GNUNET_YES);
 382   return GNUNET_OK;
 383 }
 384
 385
 386 /**
 387  * Set up a context for communicating with ARM, then
 388  * start connecting to the ARM service using that context.
 389  *
 390  * @param cfg configuration to use (needed to contact ARM;
 391  *        the ARM service may internally use a different
 392  *        configuration to determine how to start the service).
 393  * @param conn_status will be called when connecting/disconnecting
 394  * @param cls closure for conn_status
 395  * @return context to use for further ARM operations, NULL on error.
 396  */
 397 struct GNUNET_ARM_Handle *
 398 GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
 399                     GNUNET_ARM_ConnectionStatusCallback conn_status, void *cls)
 400 {
 401   struct GNUNET_ARM_Handle *h;
 402
 403   h = GNUNET_malloc (sizeof (struct GNUNET_ARM_Handle));
 404   h->cfg = GNUNET_CONFIGURATION_dup (cfg);
 405   h->currently_down = GNUNET_YES;
 406   h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 407   h->conn_status = conn_status;
 408   h->conn_status_cls = cls;
 409   if (GNUNET_OK != reconnect_arm (h))
 410   {
 411     GNUNET_free (h);
 412     return NULL;
 413   }
 414   return h;
 415 }
 416
 417
 418 /**
 419  * Disconnect from the ARM service (if connected) and destroy the context.
 420  *
 421  * @param h the handle that was being used
 422  */
 423 void
 424 GNUNET_ARM_disconnect_and_free (struct GNUNET_ARM_Handle *h)
 425 {
 426   struct ARMControlMessage *cm;
 427
 428   LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
 429   if (NULL != h->cth)
 430   {
 431     GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
 432     h->cth = NULL;
 433   }
 434   while ((NULL != (cm = h->control_pending_head))
 435          || (NULL != (cm = h->control_sent_head)) )
 436   {
 437     if (NULL != h->control_pending_head)
 438       GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
 439                                    h->control_pending_tail, cm);
 440     else
 441       GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
 442                                    h->control_sent_tail, cm);
 443     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
 444     GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
 445     if (NULL != cm->result_cont)
 446       cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED,
 447                        NULL, 0);
 448     /* FIXME: What about list callback? */
 449     GNUNET_free_non_null (cm->msg);
 450     GNUNET_free (cm);
 451   }
 452   if (NULL != h->client)
 453   {
 454     GNUNET_CLIENT_disconnect (h->client);
 455     h->client = NULL;
 456   }
 457   if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
 458   {
 459     GNUNET_SCHEDULER_cancel (h->reconnect_task);
 460     h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 461   }
 462   if (GNUNET_NO == h->service_test_is_active)
 463   {
 464     GNUNET_CONFIGURATION_destroy (h->cfg);
 465     GNUNET_free (h);
 466   }
 467 }
 468
 469
 470 /**
 471  * Message timed out. Remove it from the queue.
 472  *
 473  * @param cls the message (struct ARMControlMessage *)
 474  * @param tc task context
 475  */
 476 static void
 477 control_message_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 478 {
 479   struct ARMControlMessage *cm = cls;
 480   struct GNUNET_ARM_Message *arm_msg;
 481   LOG (GNUNET_ERROR_TYPE_DEBUG,
 482        "Control message timed out\n");
 483   arm_msg = cm->msg;
 484   if ((NULL == arm_msg) || (0 == arm_msg->request_id))
 485   {
 486     GNUNET_CONTAINER_DLL_remove (cm->h->control_pending_head,
 487                                  cm->h->control_pending_tail, cm);
 488   }
 489   else
 490   {
 491     GNUNET_CONTAINER_DLL_remove (cm->h->control_sent_head,
 492                                  cm->h->control_sent_tail, cm);
 493   }
 494   if (NULL != cm->result_cont)
 495     cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_TIMEOUT, NULL, 0);
 496   else if (NULL != cm->list_cont)
 497     cm->list_cont (cm->cont_cls, GNUNET_ARM_REQUEST_TIMEOUT, 0, NULL);
 498   GNUNET_free_non_null (cm->msg);
 499   GNUNET_free (cm);
 500 }
 501
 502
 503 #include "do_start_process.c"
 504
 505
 506 /**
 507  * A client specifically requested starting of ARM itself.
 508  * This function is called with information about whether
 509  * or not ARM is running; if it is, report success.  If
 510  * it is not, start the ARM process.
 511  *
 512  * @param cls the context for the request that we will report on (struct ARMControlMessage *)
 513  * @param tc why were we called (reason says if ARM is running)
 514  */
 515 static void
 516 arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 517 {
 518   struct ARMControlMessage *cm = cls;
 519   struct GNUNET_ARM_Handle *h;
 520   struct GNUNET_OS_Process *proc;
 521   unsigned char test_is_active;
 522   char *cbinary;
 523   char *binary;
 524   char *config;
 525   char *loprefix;
 526   char *lopostfix;
 527
 528   test_is_active = cm->h->service_test_is_active;
 529
 530   /* FIXME: shouldn't we check for GNUNET_SCHEDULER_REASON_SHUTDOWN ? */
 531   if ((GNUNET_YES == test_is_active) &&
 532       (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)))
 533   {
 534     LOG (GNUNET_ERROR_TYPE_DEBUG, "Looks like `%s' is already running.\n",
 535          "gnunet-service-arm");
 536     /* arm is running! */
 537     if (cm->result_cont)
 538       cm->result_cont (cm->cont_cls,
 539                        GNUNET_ARM_REQUEST_SENT_OK, "arm",
 540                        GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
 541   }
 542   if (GNUNET_NO == test_is_active)
 543   {
 544     /* User disconnected & destroyed ARM handle in the middle of
 545      * the service test, so we kept the handle around until now.
 546      */
 547     GNUNET_CONFIGURATION_destroy (cm->h->cfg);
 548     GNUNET_free (cm->h);
 549   }
 550   if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) ||
 551       (GNUNET_NO == test_is_active))
 552   {
 553     GNUNET_free (cm);
 554     return;
 555   }
 556   cm->h->service_test_is_active = GNUNET_NO;
 557   LOG (GNUNET_ERROR_TYPE_DEBUG,
 558        "Looks like `%s' is not running, will start it.\n",
 559        "gnunet-service-arm");
 560   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (
 561       cm->h->cfg, "arm", "PREFIX", &loprefix))
 562     loprefix = GNUNET_strdup ("");
 563   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (
 564       cm->h->cfg, "arm", "OPTIONS", &lopostfix))
 565     lopostfix = GNUNET_strdup ("");
 566   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (
 567       cm->h->cfg, "arm", "BINARY", &cbinary))
 568   {
 569     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, "arm", "BINARY");
 570     if (cm->result_cont)
 571       cm->result_cont (cm->cont_cls,
 572                        GNUNET_ARM_REQUEST_SENT_OK, "arm",
 573                        GNUNET_ARM_RESULT_IS_NOT_KNOWN);
 574     GNUNET_free (cm);
 575     GNUNET_free (loprefix);
 576     GNUNET_free (lopostfix);
 577     return;
 578   }
 579   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (
 580       cm->h->cfg, "arm", "CONFIG", &config))
 581     config = NULL;
 582   binary = GNUNET_OS_get_libexec_binary_path (cbinary);
 583   GNUNET_free (cbinary);
 584   if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (
 585           cm->h->cfg, "TESTING", "WEAKRANDOM")) &&
 586       (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (
 587           cm->h->cfg, "TESTING", "WEAKRANDOM")) &&
 588       (GNUNET_NO == GNUNET_CONFIGURATION_have_value (
 589           cm->h->cfg, "TESTING", "HOSTFILE")))
 590   {
 591     /* Means we are ONLY running locally */
 592     /* we're clearly running a test, don't daemonize */
 593     if (NULL == config)
 594       proc = do_start_process (GNUNET_NO, cm->std_inheritance,
 595                                NULL, loprefix, binary,
 596                                /* no daemonization! */
 597                                lopostfix, NULL);
 598     else
 599       proc = do_start_process (GNUNET_NO, cm->std_inheritance,
 600                                NULL, loprefix, binary, "-c", config,
 601                                /* no daemonization! */
 602                                lopostfix, NULL);
 603   }
 604   else
 605   {
 606     if (NULL == config)
 607       proc = do_start_process (GNUNET_NO, cm->std_inheritance,
 608                                NULL, loprefix, binary,
 609                                "-d", lopostfix, NULL);
 610     else
 611       proc = do_start_process (GNUNET_NO, cm->std_inheritance,
 612                                NULL, loprefix, binary, "-c", config,
 613                                "-d", lopostfix, NULL);
 614   }
 615   GNUNET_free (binary);
 616   GNUNET_free_non_null (config);
 617   GNUNET_free (loprefix);
 618   GNUNET_free (lopostfix);
 619   if (NULL == proc)
 620   {
 621     if (cm->result_cont)
 622       cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, "arm",
 623           GNUNET_ARM_RESULT_START_FAILED);
 624     GNUNET_free (cm);
 625     return;
 626   }
 627   if (cm->result_cont)
 628     cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, "arm",
 629         GNUNET_ARM_RESULT_STARTING);
 630   GNUNET_OS_process_destroy (proc);
 631   h = cm->h;
 632   GNUNET_free (cm);
 633   reconnect_arm (h);
 634 }
 635
 636
 637 /**
 638  * Start or stop a service.
 639  *
 640  * @param h handle to ARM
 641  * @param service_name name of the service
 642  * @param timeout how long to wait before failing for good
 643  * @param cb callback to invoke when service is ready
 644  * @param cb_cls closure for callback
 645  * @param type type of the request
 646  */
 647 static void
 648 change_service (struct GNUNET_ARM_Handle *h, const char *service_name,
 649                 struct GNUNET_TIME_Relative timeout, GNUNET_ARM_ResultCallback cb,
 650                 void *cb_cls, uint16_t type)
 651 {
 652   struct ARMControlMessage *cm;
 653   size_t slen;
 654   struct GNUNET_ARM_Message *msg;
 655
 656   slen = strlen (service_name) + 1;
 657   if (slen + sizeof (struct GNUNET_ARM_Message) >=
 658       GNUNET_SERVER_MAX_MESSAGE_SIZE)
 659   {
 660     GNUNET_break (0);
 661     if (cb != NULL)
 662       cb (cb_cls, GNUNET_ARM_REQUEST_TOO_LONG, NULL, 0);
 663     return;
 664   }
 665   LOG (GNUNET_ERROR_TYPE_DEBUG, "Requesting %s of service `%s'.\n",
 666        (GNUNET_MESSAGE_TYPE_ARM_START == type) ? "start" : "termination",
 667        service_name);
 668   cm = GNUNET_malloc (sizeof (struct ARMControlMessage) + slen);
 669   cm->h = h;
 670   cm->result_cont = cb;
 671   cm->cont_cls = cb_cls;
 672   cm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 673   memcpy (&cm[1], service_name, slen);
 674   msg = GNUNET_malloc (sizeof (struct GNUNET_ARM_Message) + slen);
 675   msg->header.size = htons (sizeof (struct GNUNET_ARM_Message) + slen);
 676   msg->header.type = htons (type);
 677   memcpy (&msg[1], service_name, slen);
 678   cm->msg = msg;
 679   LOG (GNUNET_ERROR_TYPE_DEBUG,
 680       "Inserting a control message into the queue. Timeout is %llu\n",
 681       GNUNET_TIME_absolute_get_remaining (cm->timeout).rel_value);
 682   GNUNET_CONTAINER_DLL_insert_tail (h->control_pending_head,
 683                                     h->control_pending_tail, cm);
 684   cm->timeout_task_id =
 685       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
 686                                     (cm->timeout), &control_message_timeout, cm);
 687   trigger_next_request (h, GNUNET_NO);
 688 }
 689
 690
 691 /**
 692  * Request for a service to be started.
 693  *
 694  * @param h handle to ARM
 695  * @param service_name name of the service
 696  * @param std_inheritance inheritance of std streams
 697  * @param timeout how long to wait before failing for good
 698  * @param cont callback to invoke after request is sent or not sent
 699  * @param cont_cls closure for callback
 700  */
 701 void
 702 GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h,
 703     const char *service_name, enum GNUNET_OS_InheritStdioFlags std_inheritance,
 704     struct GNUNET_TIME_Relative timeout, GNUNET_ARM_ResultCallback cont,
 705     void *cont_cls)
 706 {
 707   struct ARMControlMessage *cm;
 708   size_t slen;
 709
 710   LOG (GNUNET_ERROR_TYPE_DEBUG,
 711        "Asked to start service `%s' within %s\n", service_name,
 712        GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_NO));
 713   if (0 == strcasecmp ("arm", service_name))
 714   {
 715     /* Possible cases:
 716      * 1) We're connected to ARM already. Invoke the callback immediately.
 717      * 2) We're not connected to ARM.
 718      *    Cancel any reconnection attempts temporarily, then perform
 719      *    a service test.
 720      */
 721     if (GNUNET_NO == h->currently_down)
 722     {
 723       LOG (GNUNET_ERROR_TYPE_DEBUG, "ARM is already running\n");
 724       if (NULL != cont)
 725         cont (cont_cls, GNUNET_ARM_REQUEST_SENT_OK, "arm", GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
 726     }
 727     else if (GNUNET_NO == h->service_test_is_active)
 728     {
 729       if (NULL != h->cth)
 730       {
 731         GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
 732         h->cth = NULL;
 733       }
 734       if (NULL != h->client)
 735       {
 736         GNUNET_CLIENT_disconnect (h->client);
 737         h->client = NULL;
 738       }
 739       if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
 740       {
 741         GNUNET_SCHEDULER_cancel (h->reconnect_task);
 742         h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 743       }
 744
 745       LOG (GNUNET_ERROR_TYPE_DEBUG,
 746           "Not connected to ARM, will do a service test\n");
 747
 748       slen = strlen ("arm") + 1;
 749       cm = GNUNET_malloc (sizeof (struct ARMControlMessage) + slen);
 750       cm->h = h;
 751       cm->result_cont = cont;
 752       cm->cont_cls = cont_cls;
 753       cm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 754       cm->std_inheritance = std_inheritance;
 755       memcpy (&cm[1], service_name, slen);
 756       h->service_test_is_active = GNUNET_YES;
 757       GNUNET_CLIENT_service_test ("arm", h->cfg, timeout, &arm_service_report,
 758                                   cm);
 759     }
 760     else
 761     {
 762       /* Service test is already running - tell user to chill out and try
 763        * again later.
 764        */
 765       LOG (GNUNET_ERROR_TYPE_DEBUG, "Service test is already in progress, we're busy\n");
 766       if (NULL != cont)
 767         cont (cont_cls, GNUNET_ARM_REQUEST_BUSY, NULL, 0);
 768     }
 769     return;
 770   }
 771   change_service (h, service_name, timeout, cont, cont_cls,
 772                   GNUNET_MESSAGE_TYPE_ARM_START);
 773 }
 774
 775
 776 /**
 777  * Request a service to be stopped.
 778  * Stopping arm itself will not invalidate its handle, and
 779  * ARM API will try to restore connection to the ARM service,
 780  * even if ARM connection was lost because you asked for ARM to be stopped.
 781  * Call GNUNET_ARM_disconnect_and_free () to free the handle and prevent
 782  * further connection attempts.
 783  *
 784  * @param h handle to ARM
 785  * @param service_name name of the service
 786  * @param timeout how long to wait before failing for good
 787  * @param cont callback to invoke after request is sent or is not sent
 788  * @param cont_cls closure for callback
 789  */
 790 void
 791 GNUNET_ARM_request_service_stop (struct GNUNET_ARM_Handle *h,
 792     const char *service_name, struct GNUNET_TIME_Relative timeout,
 793     GNUNET_ARM_ResultCallback cont, void *cont_cls)
 794 {
 795   LOG (GNUNET_ERROR_TYPE_DEBUG,
 796        "Stopping service `%s' within %s\n",
 797        service_name,
 798        GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_NO));
 799   change_service (h, service_name, timeout, cont, cont_cls,
 800                   GNUNET_MESSAGE_TYPE_ARM_STOP);
 801 }
 802
 803
 804 /**
 805  * Request a list of running services.
 806  *
 807  * @param h handle to ARM
 808  * @param timeout how long to wait before failing for good
 809  * @param cont callback to invoke after request is sent or is not sent
 810  * @param cont_cls closure for callback
 811  */
 812 void
 813 GNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h,
 814                                  struct GNUNET_TIME_Relative timeout,
 815                                  GNUNET_ARM_ServiceListCallback cont,
 816                                  void *cont_cls)
 817 {
 818   struct ARMControlMessage *cm;
 819   struct GNUNET_ARM_Message *msg;
 820
 821   LOG (GNUNET_ERROR_TYPE_DEBUG,
 822        "Requesting LIST from ARM service with timeout: %s\n",
 823        GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_YES));
 824   cm = GNUNET_malloc (sizeof (struct ARMControlMessage));
 825   cm->h = h;
 826   cm->list_cont = cont;
 827   cm->cont_cls = cont_cls;
 828   cm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 829   msg = GNUNET_malloc (sizeof (struct GNUNET_ARM_Message));
 830   msg->header.size = htons (sizeof (struct GNUNET_ARM_Message));
 831   msg->header.type = htons (GNUNET_MESSAGE_TYPE_ARM_LIST);
 832   cm->msg = msg;
 833   GNUNET_CONTAINER_DLL_insert_tail (h->control_pending_head,
 834                                     h->control_pending_tail, cm);
 835   cm->timeout_task_id =
 836       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
 837                                     (cm->timeout), &control_message_timeout, cm);
 838   trigger_next_request (h, GNUNET_NO);
 839 }
 840
 841
 842 static struct ARMControlMessage *
 843 find_cm_by_id (struct GNUNET_ARM_Handle *h, uint64_t id)
 844 {
 845   struct ARMControlMessage *result;
 846   for (result = h->control_sent_head; result; result = result->next)
 847     if (id == result->msg->request_id)
 848       return result;
 849   return NULL;
 850 }
 851
 852
 853 /**
 854  * Handler for ARM replies.
 855  *
 856  * @param cls our "struct GNUNET_ARM_Handle"
 857  * @param msg the message received from the arm service
 858  */
 859 static void
 860 client_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 861 {
 862   struct GNUNET_ARM_Handle *h = cls;
 863   const struct GNUNET_ARM_Message *arm_msg;
 864   const struct GNUNET_ARM_ResultMessage *res;
 865   const struct GNUNET_ARM_ListResultMessage *lres;
 866   struct ARMControlMessage *cm;
 867   const char **list;
 868   const char *pos;
 869   uint64_t id;
 870   enum GNUNET_ARM_Result result;
 871   uint16_t size_check;
 872   uint16_t rcount;
 873   uint16_t msize;
 874   unsigned char fail;
 875
 876   list = NULL;
 877   if (NULL == msg)
 878   {
 879     LOG (GNUNET_ERROR_TYPE_INFO,
 880          _("Client was disconnected from arm service, trying to reconnect.\n"));
 881     reconnect_arm_later (h);
 882     return;
 883   }
 884   msize = ntohs (msg->size);
 885   LOG (GNUNET_ERROR_TYPE_DEBUG,
 886        "Processing message of type %u and size %u from arm service\n",
 887        ntohs (msg->type), msize);
 888   if (msize < sizeof (struct GNUNET_ARM_Message))
 889   {
 890     GNUNET_break (0);
 891     reconnect_arm_later (h);
 892     return;
 893   }
 894   arm_msg = (const struct GNUNET_ARM_Message *) msg;
 895   id = GNUNET_ntohll (arm_msg->request_id);
 896   cm = find_cm_by_id (h, id);
 897   if (NULL == cm)
 898   {
 899     LOG (GNUNET_ERROR_TYPE_DEBUG, "Message with unknown id %llu\n", id);
 900     return;
 901   }
 902   fail = GNUNET_NO;
 903   switch (ntohs (msg->type))
 904   {
 905   case GNUNET_MESSAGE_TYPE_ARM_RESULT:
 906     if (msize < sizeof (struct GNUNET_ARM_ResultMessage))
 907     {
 908       GNUNET_assert (0);
 909       fail = GNUNET_YES;
 910     }
 911     break;
 912   case GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT:
 913     if (msize < sizeof (struct GNUNET_ARM_ListResultMessage))
 914     {
 915       GNUNET_break (0);
 916       fail = GNUNET_YES;
 917       break;
 918     }
 919     size_check = 0;
 920     lres = (const struct GNUNET_ARM_ListResultMessage *) msg;
 921     rcount = ntohs (lres->count);
 922     {
 923       unsigned int i;
 924
 925       list = GNUNET_malloc (sizeof (const char *) * rcount);
 926       pos = (const char *)&lres[1];
 927       for (i = 0; i < rcount; i++)
 928       {
 929         const char *end = memchr (pos, 0, msize - size_check);
 930         if (NULL == end)
 931         {
 932           GNUNET_break (0);
 933           fail = GNUNET_YES;
 934           break;
 935         }
 936         list[i] = pos;
 937         size_check += (end - pos) + 1;
 938         pos = end + 1;
 939       }
 940       if (GNUNET_YES == fail)
 941       {
 942         GNUNET_free (list);
 943         list = NULL;
 944       }
 945     }
 946     break;
 947   default:
 948     fail = GNUNET_YES;
 949     break;
 950   }
 951   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
 952   GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
 953   GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
 954                                h->control_sent_tail, cm);
 955   if (GNUNET_YES == fail)
 956   {
 957     reconnect_arm_later (h);
 958     GNUNET_free (cm->msg);
 959     GNUNET_free (cm);
 960     return;
 961   }
 962   GNUNET_CLIENT_receive (h->client, &client_notify_handler, h,
 963                          GNUNET_TIME_UNIT_FOREVER_REL);
 964   switch (ntohs (msg->type))
 965   {
 966   case GNUNET_MESSAGE_TYPE_ARM_RESULT:
 967     res = (const struct GNUNET_ARM_ResultMessage *) msg;
 968     LOG (GNUNET_ERROR_TYPE_DEBUG,
 969          "Received response from ARM for service `%s': %u\n",
 970          (const char *) &cm->msg[1], ntohs (msg->type));
 971     result = (enum GNUNET_ARM_Result) ntohl (res->result);
 972     if (NULL != cm->result_cont)
 973       cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK,
 974                        (const char *) &cm->msg[1], result);
 975     break;
 976   case GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT:
 977     if (NULL != cm->list_cont)
 978         cm->list_cont (cm->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, rcount,
 979                        list);
 980     GNUNET_free (list);
 981     break;
 982   }
 983   GNUNET_free (cm->msg);
 984   GNUNET_free (cm);
 985 }
 986
 987 /* end of arm_api.c */