src/testing/testing.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2008, 2009 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 testing/testing.c
  23  * @brief convenience API for writing testcases for GNUnet
  24  *        Many testcases need to start and stop gnunetd,
  25  *        and this library is supposed to make that easier
  26  *        for TESTCASES.  Normal programs should always
  27  *        use functions from gnunet_{util,arm}_lib.h.  This API is
  28  *        ONLY for writing testcases!
  29  * @author Christian Grothoff
  30  *
  31  */
  32 #include "platform.h"
  33 #include "gnunet_arm_service.h"
  34 #include "gnunet_core_service.h"
  35 #include "gnunet_constants.h"
  36 #include "gnunet_testing_lib.h"
  37 #include "gnunet_transport_service.h"
  38 #include "gnunet_hello_lib.h"
  39
  40 #define DEBUG_TESTING GNUNET_EXTRA_LOGGING
  41
  42 #define DEBUG_TESTING_RECONNECT GNUNET_EXTRA_LOGGING
  43
  44 /**
  45  * Hack to deal with initial HELLO's being often devoid of addresses.
  46  * This hack causes 'process_hello' to ignore HELLOs without addresses.
  47  * The correct implementation would continue with 'process_hello' until
  48  * the connection could be established...
  49  */
  50 #define EMPTY_HACK GNUNET_YES
  51
  52 /**
  53  * How long do we wait after starting gnunet-service-arm
  54  * for the core service to be alive?
  55  */
  56 #define ARM_START_WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
  57
  58 /**
  59  * How many times are we willing to try to wait for "scp" or
  60  * "gnunet-service-arm" to complete (waitpid) before giving up?
  61  */
  62 #define MAX_EXEC_WAIT_RUNS 250
  63
  64 static struct GNUNET_CORE_MessageHandler no_handlers[] = { {NULL, 0, 0} };
  65
  66 #if EMPTY_HACK
  67 static int
  68 test_address (void *cls, const char *tname,
  69               struct GNUNET_TIME_Absolute expiration, const void *addr,
  70               uint16_t addrlen)
  71 {
  72   int *empty = cls;
  73
  74   *empty = GNUNET_NO;
  75   return GNUNET_OK;
  76 }
  77 #endif
  78
  79 /**
  80  * Receive the HELLO from one peer, give it to the other
  81  * and ask them to connect.
  82  *
  83  * @param cls "struct ConnectContext"
  84  * @param message HELLO message of peer
  85  */
  86 static void
  87 process_hello (void *cls, const struct GNUNET_MessageHeader *message)
  88 {
  89   struct GNUNET_TESTING_Daemon *daemon = cls;
  90   int msize;
  91
  92 #if EMPTY_HACK
  93   int empty;
  94
  95   empty = GNUNET_YES;
  96   GNUNET_assert (message != NULL);
  97   GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *) message,
  98                                   GNUNET_NO, &test_address, &empty);
  99   if (GNUNET_YES == empty)
 100   {
 101 #if DEBUG_TESTING
 102     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Skipping empty HELLO address\n");
 103 #endif
 104     return;
 105   }
 106 #endif
 107   GNUNET_assert (daemon->phase == SP_GET_HELLO ||
 108                  daemon->phase == SP_START_DONE);
 109   daemon->cb = NULL;
 110   if (daemon->task != GNUNET_SCHEDULER_NO_TASK) /* Assertion here instead? */
 111     GNUNET_SCHEDULER_cancel (daemon->task);
 112
 113   if (daemon->server != NULL)
 114   {
 115 #if DEBUG_TESTING
 116     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 117                 "Received `%s' from transport service of `%4s', disconnecting core!\n",
 118                 "HELLO", GNUNET_i2s (&daemon->id));
 119 #endif
 120     GNUNET_CORE_disconnect (daemon->server);
 121     daemon->server = NULL;
 122   }
 123
 124   msize = ntohs (message->size);
 125   if (msize < 1)
 126   {
 127     return;
 128   }
 129   if (daemon->ghh != NULL)
 130   {
 131     GNUNET_TRANSPORT_get_hello_cancel (daemon->ghh);
 132   }
 133 #if DEBUG_TESTING
 134   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 135               "Received `%s' from transport service of `%4s'\n", "HELLO",
 136               GNUNET_i2s (&daemon->id));
 137 #endif
 138
 139   GNUNET_free_non_null (daemon->hello);
 140   daemon->hello = GNUNET_malloc (msize);
 141   memcpy (daemon->hello, message, msize);
 142
 143   if (daemon->th != NULL)
 144   {
 145     GNUNET_TRANSPORT_disconnect (daemon->th);
 146     daemon->th = NULL;
 147   }
 148   daemon->phase = SP_START_DONE;
 149 }
 150
 151 static void
 152 start_fsm (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 153
 154 /**
 155  * Notify of a peer being up and running.  Scheduled as a task
 156  * so that variables which may need to be set are set before
 157  * the connect callback can set up new operations.
 158  *
 159  * @param cls the testing daemon
 160  * @param tc task scheduler context
 161  */
 162 static void
 163 notify_daemon_started (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 164 {
 165   struct GNUNET_TESTING_Daemon *d = cls;
 166   GNUNET_TESTING_NotifyDaemonRunning cb;
 167
 168   cb = d->cb;
 169   d->cb = NULL;
 170   if (NULL != cb)
 171     cb (d->cb_cls, &d->id, d->cfg, d, NULL);
 172 }
 173
 174
 175 /**
 176  * Finite-state machine for starting GNUnet.
 177  *
 178  * @param cls our "struct GNUNET_TESTING_Daemon"
 179  * @param tc unused
 180  */
 181 static void
 182 start_fsm (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 183 {
 184   struct GNUNET_TESTING_Daemon *d = cls;
 185   GNUNET_TESTING_NotifyDaemonRunning cb;
 186   enum GNUNET_OS_ProcessStatusType type;
 187   unsigned long code;
 188   char *dst;
 189   int bytes_read;
 190
 191 #if DEBUG_TESTING
 192   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer FSM is in phase %u.\n", d->phase);
 193 #endif
 194
 195   d->task = GNUNET_SCHEDULER_NO_TASK;
 196   switch (d->phase)
 197   {
 198   case SP_COPYING:
 199     /* confirm copying complete */
 200     if (GNUNET_OK != GNUNET_OS_process_status (d->proc, &type, &code))
 201     {
 202       if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)
 203       {
 204         cb = d->cb;
 205         d->cb = NULL;
 206         if (NULL != cb)
 207           cb (d->cb_cls, NULL, d->cfg, d,
 208               _
 209               ("`scp' does not seem to terminate (timeout copying config).\n"));
 210         return;
 211       }
 212       /* wait some more */
 213       d->task =
 214           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 215                                         d);
 216       return;
 217     }
 218     if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 219     {
 220       cb = d->cb;
 221       d->cb = NULL;
 222       if (NULL != cb)
 223         cb (d->cb_cls, NULL, d->cfg, d, _("`scp' did not complete cleanly.\n"));
 224       return;
 225     }
 226     GNUNET_OS_process_close (d->proc);
 227 #if DEBUG_TESTING
 228     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 229                 "Successfully copied configuration file.\n");
 230 #endif
 231     d->phase = SP_COPIED;
 232     /* fall-through */
 233   case SP_COPIED:
 234     /* Start create hostkey process if we don't already know the peer identity! */
 235     if (GNUNET_NO == d->have_hostkey)
 236     {
 237       d->pipe_stdout = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES);
 238       if (d->pipe_stdout == NULL)
 239       {
 240         cb = d->cb;
 241         d->cb = NULL;
 242         if (NULL != cb)
 243           cb (d->cb_cls, NULL, d->cfg, d,
 244               (NULL ==
 245                d->hostname) ?
 246               _("Failed to create pipe for `gnunet-peerinfo' process.\n") :
 247               _("Failed to create pipe for `ssh' process.\n"));
 248         return;
 249       }
 250       if (NULL == d->hostname)
 251       {
 252 #if DEBUG_TESTING
 253         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 254                     "Starting `%s', with command `%s %s %s %s'.\n",
 255                     "gnunet-peerinfo", "gnunet-peerinfo", "-c", d->cfgfile,
 256                     "-sq");
 257 #endif
 258         d->proc =
 259             GNUNET_OS_start_process (NULL, d->pipe_stdout, "gnunet-peerinfo",
 260                                      "gnunet-peerinfo", "-c", d->cfgfile, "-sq",
 261                                      NULL);
 262         GNUNET_DISK_pipe_close_end (d->pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
 263       }
 264       else
 265       {
 266         if (d->username != NULL)
 267           GNUNET_asprintf (&dst, "%s@%s", d->username, d->hostname);
 268         else
 269           dst = GNUNET_strdup (d->hostname);
 270
 271 #if DEBUG_TESTING
 272         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 273                     "Starting `%s', with command `%s %s %s %s %s %s'.\n",
 274                     "gnunet-peerinfo", "ssh", dst, "gnunet-peerinfo", "-c",
 275                     d->cfgfile, "-sq");
 276 #endif
 277         if (d->ssh_port_str == NULL)
 278         {
 279           d->proc = GNUNET_OS_start_process (NULL, d->pipe_stdout, "ssh", "ssh",
 280 #if !DEBUG_TESTING
 281                                              "-q",
 282 #endif
 283                                              dst, "gnunet-peerinfo", "-c",
 284                                              d->cfgfile, "-sq", NULL);
 285         }
 286         else
 287         {
 288           d->proc =
 289               GNUNET_OS_start_process (NULL, d->pipe_stdout, "ssh", "ssh", "-p",
 290                                        d->ssh_port_str,
 291 #if !DEBUG_TESTING
 292                                        "-q",
 293 #endif
 294                                        dst, "gnunet-peerinfo", "-c", d->cfgfile,
 295                                        "-sq", NULL);
 296         }
 297         GNUNET_DISK_pipe_close_end (d->pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
 298         GNUNET_free (dst);
 299       }
 300       if (NULL == d->proc)
 301       {
 302         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 303                     _("Could not start `%s' process to create hostkey.\n"),
 304                     (NULL == d->hostname) ? "gnunet-peerinfo" : "ssh");
 305         cb = d->cb;
 306         d->cb = NULL;
 307         if (NULL != cb)
 308           cb (d->cb_cls, NULL, d->cfg, d,
 309               (NULL ==
 310                d->hostname) ? _("Failed to start `gnunet-peerinfo' process.\n")
 311               : _("Failed to start `ssh' process.\n"));
 312         GNUNET_DISK_pipe_close (d->pipe_stdout);
 313         return;
 314       }
 315 #if DEBUG_TESTING
 316       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 317                   "Started `%s', waiting for hostkey.\n", "gnunet-peerinfo");
 318 #endif
 319       d->phase = SP_HOSTKEY_CREATE;
 320       d->task =
 321           GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
 322                                           (d->max_timeout),
 323                                           GNUNET_DISK_pipe_handle
 324                                           (d->pipe_stdout,
 325                                            GNUNET_DISK_PIPE_END_READ),
 326                                           &start_fsm, d);
 327     }
 328     else                        /* Already have a hostkey! */
 329     {
 330       if (d->hostkey_callback != NULL)
 331       {
 332         d->hostkey_callback (d->hostkey_cls, &d->id, d, NULL);
 333         d->hostkey_callback = NULL;
 334         d->phase = SP_HOSTKEY_CREATED;
 335       }
 336       else
 337         d->phase = SP_TOPOLOGY_SETUP;
 338
 339       /* wait some more */
 340       d->task = GNUNET_SCHEDULER_add_now (&start_fsm, d);
 341     }
 342     break;
 343   case SP_HOSTKEY_CREATE:
 344     bytes_read =
 345         GNUNET_DISK_file_read (GNUNET_DISK_pipe_handle
 346                                (d->pipe_stdout, GNUNET_DISK_PIPE_END_READ),
 347                                &d->hostkeybuf[d->hostkeybufpos],
 348                                sizeof (d->hostkeybuf) - d->hostkeybufpos);
 349     if (bytes_read > 0)
 350       d->hostkeybufpos += bytes_read;
 351
 352     if ((d->hostkeybufpos < 104) && (bytes_read > 0))
 353     {
 354       /* keep reading */
 355       d->task =
 356           GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
 357                                           (d->max_timeout),
 358                                           GNUNET_DISK_pipe_handle
 359                                           (d->pipe_stdout,
 360                                            GNUNET_DISK_PIPE_END_READ),
 361                                           &start_fsm, d);
 362       return;
 363     }
 364     d->hostkeybuf[103] = '\0';
 365
 366     if ((bytes_read < 0) ||
 367         (GNUNET_OK !=
 368          GNUNET_CRYPTO_hash_from_string (d->hostkeybuf, &d->id.hashPubKey)))
 369     {
 370       /* error */
 371       if (bytes_read < 0)
 372         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 373                     _("Error reading from gnunet-peerinfo: %s\n"),
 374                     STRERROR (errno));
 375       else
 376         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 377                     _("Malformed output from gnunet-peerinfo!\n"));
 378       cb = d->cb;
 379       d->cb = NULL;
 380       GNUNET_DISK_pipe_close (d->pipe_stdout);
 381       d->pipe_stdout = NULL;
 382       (void) GNUNET_OS_process_kill (d->proc, SIGKILL);
 383       GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (d->proc));
 384       GNUNET_OS_process_close (d->proc);
 385       d->proc = NULL;
 386       if (NULL != cb)
 387         cb (d->cb_cls, NULL, d->cfg, d, _("Failed to get hostkey!\n"));
 388       return;
 389     }
 390     d->shortname = GNUNET_strdup (GNUNET_i2s (&d->id));
 391     GNUNET_DISK_pipe_close (d->pipe_stdout);
 392     d->pipe_stdout = NULL;
 393     (void) GNUNET_OS_process_kill (d->proc, SIGKILL);
 394     GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (d->proc));
 395     GNUNET_OS_process_close (d->proc);
 396     d->proc = NULL;
 397     d->have_hostkey = GNUNET_YES;
 398     if (d->hostkey_callback != NULL)
 399     {
 400       d->hostkey_callback (d->hostkey_cls, &d->id, d, NULL);
 401       d->hostkey_callback = NULL;
 402       d->phase = SP_HOSTKEY_CREATED;
 403     }
 404     else
 405     {
 406       d->phase = SP_TOPOLOGY_SETUP;
 407     }
 408 #if DEBUG_TESTING
 409     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully got hostkey!\n");
 410 #endif
 411     /* Fall through */
 412   case SP_HOSTKEY_CREATED:
 413     /* wait for topology finished */
 414     if ((GNUNET_YES == d->dead) ||
 415         (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0))
 416     {
 417       cb = d->cb;
 418       d->cb = NULL;
 419       if (NULL != cb)
 420         cb (d->cb_cls, NULL, d->cfg, d,
 421             _("`Failed while waiting for topology setup!\n"));
 422       return;
 423     }
 424
 425     d->task =
 426         GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 427                                       d);
 428     break;
 429   case SP_TOPOLOGY_SETUP:      /* Indicates topology setup has completed! */
 430     /* start GNUnet on remote host */
 431     if (NULL == d->hostname)
 432     {
 433 #if DEBUG_TESTING
 434       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 435                   "Starting `%s', with command `%s %s %s %s %s %s'.\n",
 436                   "gnunet-arm", "gnunet-arm", "-c", d->cfgfile, "-L", "DEBUG",
 437                   "-s");
 438 #endif
 439       d->proc =
 440           GNUNET_OS_start_process (NULL, NULL, "gnunet-arm", "gnunet-arm", "-c",
 441                                    d->cfgfile,
 442 #if DEBUG_TESTING
 443                                    "-L", "DEBUG",
 444 #endif
 445                                    "-s", "-q", "-T",
 446                                    GNUNET_TIME_relative_to_string
 447                                    (GNUNET_TIME_absolute_get_remaining
 448                                     (d->max_timeout)), NULL);
 449     }
 450     else
 451     {
 452       if (d->username != NULL)
 453         GNUNET_asprintf (&dst, "%s@%s", d->username, d->hostname);
 454       else
 455         dst = GNUNET_strdup (d->hostname);
 456
 457 #if DEBUG_TESTING
 458       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 459                   "Starting `%s', with command `%s %s %s %s %s %s %s %s'.\n",
 460                   "gnunet-arm", "ssh", dst, "gnunet-arm", "-c", d->cfgfile,
 461                   "-L", "DEBUG", "-s", "-q");
 462 #endif
 463       if (d->ssh_port_str == NULL)
 464       {
 465         d->proc = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
 466 #if !DEBUG_TESTING
 467                                            "-q",
 468 #endif
 469                                            dst, "gnunet-arm",
 470 #if DEBUG_TESTING
 471                                            "-L", "DEBUG",
 472 #endif
 473                                            "-c", d->cfgfile, "-s", "-q", "-T",
 474                                            GNUNET_TIME_relative_to_string
 475                                            (GNUNET_TIME_absolute_get_remaining
 476                                             (d->max_timeout)), NULL);
 477       }
 478       else
 479       {
 480
 481         d->proc =
 482             GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh", "-p",
 483                                      d->ssh_port_str,
 484 #if !DEBUG_TESTING
 485                                      "-q",
 486 #endif
 487                                      dst, "gnunet-arm",
 488 #if DEBUG_TESTING
 489                                      "-L", "DEBUG",
 490 #endif
 491                                      "-c", d->cfgfile, "-s", "-q", "-T",
 492                                      GNUNET_TIME_relative_to_string
 493                                      (GNUNET_TIME_absolute_get_remaining
 494                                       (d->max_timeout)), NULL);
 495       }
 496       GNUNET_free (dst);
 497     }
 498     if (NULL == d->proc)
 499     {
 500       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 501                   _("Could not start `%s' process to start GNUnet.\n"),
 502                   (NULL == d->hostname) ? "gnunet-arm" : "ssh");
 503       cb = d->cb;
 504       d->cb = NULL;
 505       if (NULL != cb)
 506         cb (d->cb_cls, NULL, d->cfg, d,
 507             (NULL ==
 508              d->hostname) ? _("Failed to start `gnunet-arm' process.\n") :
 509             _("Failed to start `ssh' process.\n"));
 510       return;
 511     }
 512 #if DEBUG_TESTING
 513     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 514                 "Started `%s', waiting for `%s' to be up.\n", "gnunet-arm",
 515                 "gnunet-service-core");
 516 #endif
 517     d->phase = SP_START_ARMING;
 518     d->task =
 519         GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 520                                       d);
 521     break;
 522   case SP_START_ARMING:
 523     if (GNUNET_OK != GNUNET_OS_process_status (d->proc, &type, &code))
 524     {
 525       if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)
 526       {
 527         cb = d->cb;
 528         d->cb = NULL;
 529         if (NULL != cb)
 530           cb (d->cb_cls, NULL, d->cfg, d,
 531               (NULL ==
 532                d->hostname) ? _("`gnunet-arm' does not seem to terminate.\n") :
 533               _("`ssh' does not seem to terminate.\n"));
 534         GNUNET_CONFIGURATION_destroy (d->cfg);
 535         GNUNET_free (d->cfgfile);
 536         GNUNET_free_non_null (d->hostname);
 537         GNUNET_free_non_null (d->username);
 538         GNUNET_free (d->proc);
 539         GNUNET_free (d);
 540         return;
 541       }
 542       /* wait some more */
 543       d->task =
 544           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 545                                         d);
 546       return;
 547     }
 548 #if DEBUG_TESTING
 549     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully started `%s'.\n",
 550                 "gnunet-arm");
 551 #endif
 552     GNUNET_free (d->proc);
 553     d->phase = SP_START_CORE;
 554 #if DEBUG_TESTING
 555     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Calling CORE_connect\n");
 556 #endif
 557     /* Fall through */
 558   case SP_START_CORE:
 559     if (d->server != NULL)
 560       GNUNET_CORE_disconnect (d->server);
 561
 562     d->th = GNUNET_TRANSPORT_connect (d->cfg, &d->id, d, NULL, NULL, NULL);
 563     if (d->th == NULL)
 564     {
 565       if (GNUNET_YES == d->dead)
 566         GNUNET_TESTING_daemon_stop (d,
 567                                     GNUNET_TIME_absolute_get_remaining
 568                                     (d->max_timeout), d->dead_cb,
 569                                     d->dead_cb_cls, GNUNET_YES, GNUNET_NO);
 570       else if (NULL != d->cb)
 571         d->cb (d->cb_cls, &d->id, d->cfg, d,
 572                _("Failed to connect to transport service!\n"));
 573       return;
 574     }
 575 #if DEBUG_TESTING
 576     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 577                 "Connected to transport service `%s', getting HELLO\n",
 578                 GNUNET_i2s (&d->id));
 579 #endif
 580
 581     d->ghh = GNUNET_TRANSPORT_get_hello (d->th, &process_hello, d);
 582     /* FIXME: store task ID somewhere! */
 583     GNUNET_SCHEDULER_add_now (&notify_daemon_started, d);
 584     /*cb = d->cb;
 585      * d->cb = NULL;
 586      * if (NULL != cb)
 587      * cb (d->cb_cls, &d->id, d->cfg, d, NULL); */
 588     d->running = GNUNET_YES;
 589     d->phase = SP_GET_HELLO;
 590     break;
 591   case SP_GET_HELLO:
 592     if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)
 593     {
 594       if (d->server != NULL)
 595         GNUNET_CORE_disconnect (d->server);
 596       if (d->th != NULL)
 597         GNUNET_TRANSPORT_disconnect (d->th);
 598       cb = d->cb;
 599       d->cb = NULL;
 600       if (NULL != cb)
 601         cb (d->cb_cls, NULL, d->cfg, d, _("Unable to get HELLO for peer!\n"));
 602       GNUNET_CONFIGURATION_destroy (d->cfg);
 603       GNUNET_free (d->cfgfile);
 604       GNUNET_free_non_null (d->hostname);
 605       GNUNET_free_non_null (d->username);
 606       GNUNET_free (d);
 607       return;
 608     }
 609     if (d->hello != NULL)
 610       return;
 611     GNUNET_assert (d->task == GNUNET_SCHEDULER_NO_TASK);
 612     d->task =
 613         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 614                                       (GNUNET_CONSTANTS_SERVICE_RETRY, 2),
 615                                       &start_fsm, d);
 616     break;
 617   case SP_START_DONE:
 618     GNUNET_break (0);
 619     break;
 620   case SP_SERVICE_START:
 621     /* confirm gnunet-arm exited */
 622     if (GNUNET_OK != GNUNET_OS_process_status (d->proc, &type, &code))
 623     {
 624       if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)
 625       {
 626         cb = d->cb;
 627         d->cb = NULL;
 628         if (NULL != cb)
 629           cb (d->cb_cls, NULL, d->cfg, d,
 630               (NULL ==
 631                d->hostname) ? _("`gnunet-arm' does not seem to terminate.\n") :
 632               _("`ssh' does not seem to terminate.\n"));
 633         return;
 634       }
 635       /* wait some more */
 636       d->task =
 637           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 638                                         d);
 639       return;
 640     }
 641 #if EXTRA_CHECKS
 642     if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 643     {
 644       cb = d->cb;
 645       d->cb = NULL;
 646       if (NULL != cb)
 647         cb (d->cb_cls, NULL, d->cfg, d,
 648             (NULL ==
 649              d->hostname) ?
 650             _
 651             ("`gnunet-arm' terminated with non-zero exit status (or timed out)!\n")
 652             : _("`ssh' does not seem to terminate.\n"));
 653       return;
 654     }
 655 #endif
 656 #if DEBUG_TESTING
 657     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service startup complete!\n");
 658 #endif
 659     cb = d->cb;
 660     d->cb = NULL;
 661     d->phase = SP_START_DONE;
 662     if (NULL != cb)
 663       cb (d->cb_cls, &d->id, d->cfg, d, NULL);
 664     break;
 665   case SP_SERVICE_SHUTDOWN_START:
 666     /* confirm copying complete */
 667     if (GNUNET_OK != GNUNET_OS_process_status (d->proc, &type, &code))
 668     {
 669       if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)
 670       {
 671         if (NULL != d->dead_cb)
 672           d->dead_cb (d->dead_cb_cls,
 673                       _
 674                       ("either `gnunet-arm' or `ssh' does not seem to terminate.\n"));
 675         return;
 676       }
 677       /* wait some more */
 678       d->task =
 679           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 680                                         d);
 681       return;
 682     }
 683 #if EXTRA_CHECKS
 684     if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 685     {
 686       if (NULL != d->dead_cb)
 687         d->dead_cb (d->dead_cb_cls,
 688                     _
 689                     ("shutdown (either `gnunet-arm' or `ssh') did not complete cleanly.\n"));
 690       return;
 691     }
 692 #endif
 693 #if DEBUG_TESTING
 694     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service shutdown complete.\n");
 695 #endif
 696     if (NULL != d->dead_cb)
 697       d->dead_cb (d->dead_cb_cls, NULL);
 698     break;
 699   case SP_SHUTDOWN_START:
 700     /* confirm copying complete */
 701     if (GNUNET_OK != GNUNET_OS_process_status (d->proc, &type, &code))
 702     {
 703       if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)
 704       {
 705         if (NULL != d->dead_cb)
 706           d->dead_cb (d->dead_cb_cls,
 707                       _
 708                       ("either `gnunet-arm' or `ssh' does not seem to terminate.\n"));
 709         if (d->th != NULL)
 710         {
 711           GNUNET_TRANSPORT_get_hello_cancel (d->ghh);
 712           d->ghh = NULL;
 713           GNUNET_TRANSPORT_disconnect (d->th);
 714           d->th = NULL;
 715         }
 716         GNUNET_CONFIGURATION_destroy (d->cfg);
 717         GNUNET_free (d->cfgfile);
 718         GNUNET_free_non_null (d->hello);
 719         GNUNET_free_non_null (d->hostname);
 720         GNUNET_free_non_null (d->username);
 721         GNUNET_free_non_null (d->shortname);
 722         GNUNET_free_non_null (d->proc);
 723         d->proc = NULL;
 724         GNUNET_free (d);
 725         return;
 726       }
 727       /* wait some more */
 728       d->task =
 729           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 730                                         d);
 731       return;
 732     }
 733     if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 734     {
 735       if (NULL != d->dead_cb)
 736         d->dead_cb (d->dead_cb_cls,
 737                     _
 738                     ("shutdown (either `gnunet-arm' or `ssh') did not complete cleanly.\n"));
 739       if (d->th != NULL)
 740       {
 741         GNUNET_TRANSPORT_get_hello_cancel (d->ghh);
 742         d->ghh = NULL;
 743         GNUNET_TRANSPORT_disconnect (d->th);
 744         d->th = NULL;
 745       }
 746       if (d->server != NULL)
 747       {
 748         GNUNET_CORE_disconnect (d->server);
 749         d->server = NULL;
 750       }
 751       GNUNET_CONFIGURATION_destroy (d->cfg);
 752       GNUNET_free (d->cfgfile);
 753       GNUNET_free_non_null (d->hello);
 754       GNUNET_free_non_null (d->hostname);
 755       GNUNET_free_non_null (d->username);
 756       GNUNET_free_non_null (d->shortname);
 757       GNUNET_free_non_null (d->proc);
 758       d->proc = NULL;
 759       GNUNET_free (d);
 760       return;
 761     }
 762 #if DEBUG_TESTING
 763     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer shutdown complete.\n");
 764 #endif
 765     if (d->server != NULL)
 766     {
 767       GNUNET_CORE_disconnect (d->server);
 768       d->server = NULL;
 769     }
 770
 771     if (d->th != NULL)
 772     {
 773       GNUNET_TRANSPORT_get_hello_cancel (d->ghh);
 774       d->ghh = NULL;
 775       GNUNET_TRANSPORT_disconnect (d->th);
 776       d->th = NULL;
 777     }
 778
 779     if (NULL != d->dead_cb)
 780       d->dead_cb (d->dead_cb_cls, NULL);
 781
 782     /* state clean up and notifications */
 783     if (d->churn == GNUNET_NO)
 784     {
 785       GNUNET_CONFIGURATION_destroy (d->cfg);
 786       GNUNET_free (d->cfgfile);
 787       GNUNET_free_non_null (d->hostname);
 788       GNUNET_free_non_null (d->username);
 789     }
 790
 791     GNUNET_free_non_null (d->hello);
 792     d->hello = NULL;
 793     GNUNET_free_non_null (d->shortname);
 794     GNUNET_free_non_null (d->proc);
 795     d->proc = NULL;
 796     d->shortname = NULL;
 797     if (d->churn == GNUNET_NO)
 798       GNUNET_free (d);
 799
 800     break;
 801   case SP_CONFIG_UPDATE:
 802     /* confirm copying complete */
 803     if (GNUNET_OK != GNUNET_OS_process_status (d->proc, &type, &code))
 804     {
 805       if (GNUNET_TIME_absolute_get_remaining (d->max_timeout).rel_value == 0)   /* FIXME: config update should take timeout parameter! */
 806       {
 807         cb = d->cb;
 808         d->cb = NULL;
 809         if (NULL != cb)
 810           cb (d->cb_cls, NULL, d->cfg, d,
 811               _("`scp' does not seem to terminate.\n"));
 812         return;
 813       }
 814       /* wait some more */
 815       d->task =
 816           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
 817                                         d);
 818       return;
 819     }
 820     if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 821     {
 822       if (NULL != d->update_cb)
 823         d->update_cb (d->update_cb_cls, _("`scp' did not complete cleanly.\n"));
 824       return;
 825     }
 826 #if DEBUG_TESTING
 827     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 828                 "Successfully copied configuration file.\n");
 829 #endif
 830     if (NULL != d->update_cb)
 831       d->update_cb (d->update_cb_cls, NULL);
 832     d->phase = SP_START_DONE;
 833     break;
 834   }
 835 }
 836
 837 /**
 838  * Continues GNUnet daemon startup when user wanted to be notified
 839  * once a hostkey was generated (for creating friends files, blacklists,
 840  * etc.).
 841  *
 842  * @param daemon the daemon to finish starting
 843  */
 844 void
 845 GNUNET_TESTING_daemon_continue_startup (struct GNUNET_TESTING_Daemon *daemon)
 846 {
 847   GNUNET_assert (daemon->phase == SP_HOSTKEY_CREATED);
 848   daemon->phase = SP_TOPOLOGY_SETUP;
 849 }
 850
 851 /**
 852  * Check whether the given daemon is running.
 853  *
 854  * @param daemon the daemon to check
 855  *
 856  * @return GNUNET_YES if the daemon is up, GNUNET_NO if the
 857  *         daemon is down, GNUNET_SYSERR on error.
 858  */
 859 int
 860 GNUNET_TESTING_test_daemon_running (struct GNUNET_TESTING_Daemon *daemon)
 861 {
 862   if (daemon == NULL)
 863     return GNUNET_SYSERR;
 864
 865   if (daemon->running == GNUNET_YES)
 866     return GNUNET_YES;
 867   return GNUNET_NO;
 868 }
 869
 870
 871 /**
 872  * Starts a GNUnet daemon service which has been previously stopped.
 873  *
 874  * @param d the daemon for which the service should be started
 875  * @param service the name of the service to start
 876  * @param timeout how long to wait for process for shutdown to complete
 877  * @param cb function called once the service starts
 878  * @param cb_cls closure for cb
 879  */
 880 void
 881 GNUNET_TESTING_daemon_start_stopped_service (struct GNUNET_TESTING_Daemon *d,
 882                                              char *service,
 883                                              struct GNUNET_TIME_Relative
 884                                              timeout,
 885                                              GNUNET_TESTING_NotifyDaemonRunning
 886                                              cb, void *cb_cls)
 887 {
 888   char *arg;
 889
 890   d->cb = cb;
 891   d->cb_cls = cb_cls;
 892
 893   GNUNET_assert (d->running == GNUNET_YES);
 894
 895   if (d->phase == SP_CONFIG_UPDATE)
 896   {
 897     GNUNET_SCHEDULER_cancel (d->task);
 898     d->phase = SP_START_DONE;
 899   }
 900
 901   if (d->churned_services == NULL)
 902   {
 903     d->cb (d->cb_cls, &d->id, d->cfg, d,
 904            "No service has been churned off yet!!");
 905     return;
 906   }
 907   d->phase = SP_SERVICE_START;
 908   GNUNET_free (d->churned_services);
 909   d->churned_services = NULL;
 910   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
 911   /* Check if this is a local or remote process */
 912   if (NULL != d->hostname)
 913   {
 914 #if DEBUG_TESTING
 915     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 916                 "Starting gnunet-arm with config `%s' on host `%s'.\n",
 917                 d->cfgfile, d->hostname);
 918 #endif
 919
 920     if (d->username != NULL)
 921       GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
 922     else
 923       arg = GNUNET_strdup (d->hostname);
 924
 925     d->proc = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
 926 #if !DEBUG_TESTING
 927                                        "-q",
 928 #endif
 929                                        arg, "gnunet-arm",
 930 #if DEBUG_TESTING
 931                                        "-L", "DEBUG",
 932 #endif
 933                                        "-c", d->cfgfile, "-i", service, "-q",
 934                                        "-T",
 935                                        GNUNET_TIME_relative_to_string (timeout),
 936                                        NULL);
 937     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 938                 "Starting gnunet-arm with command ssh %s gnunet-arm -c %s -i %s -q\n",
 939                 arg, "gnunet-arm", d->cfgfile, service);
 940     GNUNET_free (arg);
 941   }
 942   else
 943   {
 944 #if DEBUG_TESTING
 945     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 946                 "Starting gnunet-arm with config `%s' locally.\n", d->cfgfile);
 947 #endif
 948     d->proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm", "gnunet-arm",
 949 #if DEBUG_TESTING
 950                                        "-L", "DEBUG",
 951 #endif
 952                                        "-c", d->cfgfile, "-i", service, "-q",
 953                                        "-T",
 954                                        GNUNET_TIME_relative_to_string (timeout),
 955                                        NULL);
 956   }
 957
 958   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
 959   d->task = GNUNET_SCHEDULER_add_now (&start_fsm, d);
 960 }
 961
 962 /**
 963  * Starts a GNUnet daemon's service.
 964  *
 965  * @param d the daemon for which the service should be started
 966  * @param service the name of the service to start
 967  * @param timeout how long to wait for process for startup
 968  * @param cb function called once gnunet-arm returns
 969  * @param cb_cls closure for cb
 970  */
 971 void
 972 GNUNET_TESTING_daemon_start_service (struct GNUNET_TESTING_Daemon *d,
 973                                      const char *service,
 974                                      struct GNUNET_TIME_Relative timeout,
 975                                      GNUNET_TESTING_NotifyDaemonRunning cb,
 976                                      void *cb_cls)
 977 {
 978   char *arg;
 979
 980   d->cb = cb;
 981   d->cb_cls = cb_cls;
 982
 983   GNUNET_assert (service != NULL);
 984   GNUNET_assert (d->running == GNUNET_YES);
 985   GNUNET_assert (d->phase == SP_START_DONE);
 986
 987 #if DEBUG_TESTING
 988   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 989               _("Starting service %s for peer `%4s'\n"), service,
 990               GNUNET_i2s (&d->id));
 991 #endif
 992
 993   d->phase = SP_SERVICE_START;
 994   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
 995   /* Check if this is a local or remote process */
 996   if (NULL != d->hostname)
 997   {
 998 #if DEBUG_TESTING
 999     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1000                 "Starting gnunet-arm with config `%s' on host `%s'.\n",
1001                 d->cfgfile, d->hostname);
1002 #endif
1003
1004     if (d->username != NULL)
1005       GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
1006     else
1007       arg = GNUNET_strdup (d->hostname);
1008
1009     d->proc = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
1010 #if !DEBUG_TESTING
1011                                        "-q",
1012 #endif
1013                                        arg, "gnunet-arm",
1014 #if DEBUG_TESTING
1015                                        "-L", "DEBUG",
1016 #endif
1017                                        "-c", d->cfgfile, "-i", service, "-q",
1018                                        "-T",
1019                                        GNUNET_TIME_relative_to_string (timeout),
1020                                        NULL);
1021     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1022                 "Starting gnunet-arm with command ssh %s gnunet-arm -c %s -i %s -q -T %s\n",
1023                 arg, "gnunet-arm", d->cfgfile, service,
1024                 GNUNET_TIME_relative_to_string (timeout));
1025     GNUNET_free (arg);
1026   }
1027   else
1028   {
1029 #if DEBUG_TESTING
1030     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1031                 "Starting gnunet-arm with config `%s' locally.\n", d->cfgfile);
1032 #endif
1033     d->proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm", "gnunet-arm",
1034 #if DEBUG_TESTING
1035                                        "-L", "DEBUG",
1036 #endif
1037                                        "-c", d->cfgfile, "-i", service, "-q",
1038                                        "-T",
1039                                        GNUNET_TIME_relative_to_string (timeout),
1040                                        NULL);
1041     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1042                 "Starting gnunet-arm with command %s -c %s -i %s -q -T %s\n",
1043                 "gnunet-arm", d->cfgfile, service,
1044                 GNUNET_TIME_relative_to_string (timeout));
1045   }
1046
1047   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1048   d->task = GNUNET_SCHEDULER_add_now (&start_fsm, d);
1049 }
1050
1051 /**
1052  * Start a peer that has previously been stopped using the daemon_stop
1053  * call (and files weren't deleted and the allow restart flag)
1054  *
1055  * @param daemon the daemon to start (has been previously stopped)
1056  * @param timeout how long to wait for restart
1057  * @param cb the callback for notification when the peer is running
1058  * @param cb_cls closure for the callback
1059  */
1060 void
1061 GNUNET_TESTING_daemon_start_stopped (struct GNUNET_TESTING_Daemon *daemon,
1062                                      struct GNUNET_TIME_Relative timeout,
1063                                      GNUNET_TESTING_NotifyDaemonRunning cb,
1064                                      void *cb_cls)
1065 {
1066   if (daemon->running == GNUNET_YES)
1067   {
1068     cb (cb_cls, &daemon->id, daemon->cfg, daemon,
1069         "Daemon already running, can't restart!");
1070     return;
1071   }
1072
1073   daemon->cb = cb;
1074   daemon->cb_cls = cb_cls;
1075   daemon->phase = SP_TOPOLOGY_SETUP;
1076   daemon->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1077   /* FIXME: why add_continuation? */
1078   GNUNET_SCHEDULER_add_continuation (&start_fsm, daemon,
1079                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
1080 }
1081
1082 /**
1083  * Starts a GNUnet daemon.  GNUnet must be installed on the target
1084  * system and available in the PATH.  The machine must furthermore be
1085  * reachable via "ssh" (unless the hostname is "NULL") without the
1086  * need to enter a password.
1087  *
1088  * @param cfg configuration to use
1089  * @param timeout how long to wait starting up peers
1090  * @param pretend GNUNET_YES to set up files but not start peer GNUNET_NO
1091  *                to really start the peer (default)
1092  * @param hostname name of the machine where to run GNUnet
1093  *        (use NULL for localhost).
1094  * @param ssh_username ssh username to use when connecting to hostname
1095  * @param sshport port to pass to ssh process when connecting to hostname
1096  * @param hostkey pointer to a hostkey to be written to disk (instead of being generated)
1097  * @param hostkey_callback function to call once the hostkey has been
1098  *        generated for this peer, but it hasn't yet been started
1099  *        (NULL to start immediately, otherwise waits on GNUNET_TESTING_daemon_continue_start)
1100  * @param hostkey_cls closure for hostkey callback
1101  * @param cb function to call once peer is up, or failed to start
1102  * @param cb_cls closure for cb
1103  * @return handle to the daemon (actual start will be completed asynchronously)
1104  */
1105 struct GNUNET_TESTING_Daemon *
1106 GNUNET_TESTING_daemon_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
1107                              struct GNUNET_TIME_Relative timeout, int pretend,
1108                              const char *hostname, const char *ssh_username,
1109                              uint16_t sshport, const char *hostkey,
1110                              GNUNET_TESTING_NotifyHostkeyCreated
1111                              hostkey_callback, void *hostkey_cls,
1112                              GNUNET_TESTING_NotifyDaemonRunning cb,
1113                              void *cb_cls)
1114 {
1115   struct GNUNET_TESTING_Daemon *ret;
1116   char *arg;
1117   char *username;
1118   char *servicehome;
1119   char *baseservicehome;
1120   char *slash;
1121   char *hostkeyfile;
1122   char *temp_file_name;
1123   struct GNUNET_DISK_FileHandle *fn;
1124   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
1125   struct GNUNET_CRYPTO_RsaPrivateKey *private_key;
1126
1127   ret = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Daemon));
1128   ret->hostname = (hostname == NULL) ? NULL : GNUNET_strdup (hostname);
1129   if (sshport != 0)
1130   {
1131     GNUNET_asprintf (&ret->ssh_port_str, "%d", sshport);
1132   }
1133   else
1134     ret->ssh_port_str = NULL;
1135
1136   /* Find service home and base service home directories, create it if it doesn't exist */
1137   GNUNET_assert (GNUNET_OK ==
1138                  GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS",
1139                                                         "SERVICEHOME",
1140                                                         &servicehome));
1141
1142   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_create (servicehome));
1143   GNUNET_asprintf (&temp_file_name, "%s/gnunet-testing-config", servicehome);
1144   ret->cfgfile = GNUNET_DISK_mktemp (temp_file_name);
1145   GNUNET_free (temp_file_name);
1146 #if DEBUG_TESTING
1147   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1148               "Setting up peer with configuration file `%s'.\n", ret->cfgfile);
1149 #endif
1150   if (NULL == ret->cfgfile)
1151   {
1152     GNUNET_free_non_null (ret->ssh_port_str);
1153     GNUNET_free_non_null (ret->hostname);
1154     GNUNET_free (ret);
1155     return NULL;
1156   }
1157   ret->hostkey_callback = hostkey_callback;
1158   ret->hostkey_cls = hostkey_cls;
1159   ret->cb = cb;
1160   ret->cb_cls = cb_cls;
1161   ret->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1162   ret->cfg = GNUNET_CONFIGURATION_dup (cfg);
1163   GNUNET_CONFIGURATION_set_value_string (ret->cfg, "PATHS", "DEFAULTCONFIG",
1164                                          ret->cfgfile);
1165
1166   if (hostkey != NULL)          /* Get the peer identity from the hostkey */
1167   {
1168     private_key = GNUNET_CRYPTO_rsa_decode_key (hostkey, HOSTKEYFILESIZE);
1169     GNUNET_assert (private_key != NULL);
1170     GNUNET_CRYPTO_rsa_key_get_public (private_key, &public_key);
1171     GNUNET_CRYPTO_hash (&public_key,
1172                         sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
1173                         &ret->id.hashPubKey);
1174     ret->shortname = GNUNET_strdup (GNUNET_i2s (&ret->id));
1175     ret->have_hostkey = GNUNET_YES;
1176     GNUNET_CRYPTO_rsa_key_free (private_key);
1177   }
1178
1179   /* Write hostkey to file, if we were given one */
1180   hostkeyfile = NULL;
1181   if (hostkey != NULL)
1182   {
1183     GNUNET_asprintf (&hostkeyfile, "%s/.hostkey", servicehome);
1184     fn = GNUNET_DISK_file_open (hostkeyfile,
1185                                 GNUNET_DISK_OPEN_READWRITE |
1186                                 GNUNET_DISK_OPEN_CREATE,
1187                                 GNUNET_DISK_PERM_USER_READ |
1188                                 GNUNET_DISK_PERM_USER_WRITE);
1189     GNUNET_assert (fn != NULL);
1190     GNUNET_assert (HOSTKEYFILESIZE ==
1191                    GNUNET_DISK_file_write (fn, hostkey, HOSTKEYFILESIZE));
1192     GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fn));
1193   }
1194
1195   /* write configuration to temporary file */
1196   if (GNUNET_OK != GNUNET_CONFIGURATION_write (ret->cfg, ret->cfgfile))
1197   {
1198     if (0 != UNLINK (ret->cfgfile))
1199       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
1200                                 ret->cfgfile);
1201     GNUNET_CONFIGURATION_destroy (ret->cfg);
1202     GNUNET_free_non_null (ret->hostname);
1203     GNUNET_free (ret->cfgfile);
1204     GNUNET_free (ret);
1205     return NULL;
1206   }
1207   if (ssh_username != NULL)
1208     username = GNUNET_strdup (ssh_username);
1209   if ((ssh_username == NULL) &&
1210       (GNUNET_OK !=
1211        GNUNET_CONFIGURATION_get_value_string (cfg, "TESTING", "USERNAME",
1212                                               &username)))
1213   {
1214     if (NULL != getenv ("USER"))
1215       username = GNUNET_strdup (getenv ("USER"));
1216     else
1217       username = NULL;
1218   }
1219   ret->username = username;
1220
1221   if (GNUNET_NO == pretend)     /* Copy files, enter finite state machine */
1222   {
1223     /* copy directory to remote host */
1224     if (NULL != hostname)
1225     {
1226 #if DEBUG_TESTING
1227       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1228                   "Copying configuration directory to host `%s'.\n", hostname);
1229 #endif
1230       baseservicehome = GNUNET_strdup (servicehome);
1231       /* Remove trailing /'s */
1232       while (baseservicehome[strlen (baseservicehome) - 1] == '/')
1233         baseservicehome[strlen (baseservicehome) - 1] = '\0';
1234       /* Find next directory /, jump one ahead */
1235       slash = strrchr (baseservicehome, '/');
1236       if (slash != NULL)
1237         *(++slash) = '\0';
1238
1239       ret->phase = SP_COPYING;
1240       if (NULL != username)
1241         GNUNET_asprintf (&arg, "%s@%s:%s", username, hostname, baseservicehome);
1242       else
1243         GNUNET_asprintf (&arg, "%s:%s", hostname, baseservicehome);
1244       GNUNET_free (baseservicehome);
1245       if (ret->ssh_port_str == NULL)
1246       {
1247         ret->proc = GNUNET_OS_start_process (NULL, NULL, "scp", "scp", "-r",
1248 #if !DEBUG_TESTING
1249                                              "-q",
1250 #endif
1251                                              servicehome, arg, NULL);
1252 #if DEBUG_TESTING
1253         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1254                     "copying directory with command scp -r %s %s\n",
1255                     servicehome, arg);
1256 #endif
1257       }
1258       else
1259       {
1260         ret->proc =
1261             GNUNET_OS_start_process (NULL, NULL, "scp", "scp", "-r", "-P",
1262                                      ret->ssh_port_str,
1263 #if !DEBUG_TESTING
1264                                      "-q",
1265 #endif
1266                                      servicehome, arg, NULL);
1267       }
1268       GNUNET_free (arg);
1269       if (NULL == ret->proc)
1270       {
1271         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1272                     _
1273                     ("Could not start `%s' process to copy configuration directory.\n"),
1274                     "scp");
1275         if (0 != UNLINK (ret->cfgfile))
1276           GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
1277                                     ret->cfgfile);
1278         GNUNET_CONFIGURATION_destroy (ret->cfg);
1279         GNUNET_free_non_null (ret->hostname);
1280         GNUNET_free_non_null (ret->username);
1281         GNUNET_free (ret->cfgfile);
1282         GNUNET_free (ret);
1283         if ((hostkey != NULL) && (0 != UNLINK (hostkeyfile)))
1284           GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
1285                                     hostkeyfile);
1286         GNUNET_free_non_null (hostkeyfile);
1287         GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (servicehome));
1288         GNUNET_free (servicehome);
1289         return NULL;
1290       }
1291
1292       ret->task =
1293           GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm,
1294                                         ret);
1295       GNUNET_free_non_null (hostkeyfile);
1296       GNUNET_free (servicehome);
1297       return ret;
1298     }
1299 #if DEBUG_TESTING
1300     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1301                 "No need to copy configuration file since we are running locally.\n");
1302 #endif
1303     ret->phase = SP_COPIED;
1304     /* FIXME: why add_cont? */
1305     GNUNET_SCHEDULER_add_continuation (&start_fsm, ret,
1306                                        GNUNET_SCHEDULER_REASON_PREREQ_DONE);
1307   }
1308   GNUNET_free_non_null (hostkeyfile);
1309   GNUNET_free (servicehome);
1310   return ret;
1311 }
1312
1313
1314 /**
1315  * Restart (stop and start) a GNUnet daemon.
1316  *
1317  * @param d the daemon that should be restarted
1318  * @param cb function called once the daemon is (re)started
1319  * @param cb_cls closure for cb
1320  */
1321 void
1322 GNUNET_TESTING_daemon_restart (struct GNUNET_TESTING_Daemon *d,
1323                                GNUNET_TESTING_NotifyDaemonRunning cb,
1324                                void *cb_cls)
1325 {
1326   char *arg;
1327   char *del_arg;
1328
1329   del_arg = NULL;
1330   if (NULL != d->cb)
1331   {
1332     d->dead = GNUNET_YES;
1333     return;
1334   }
1335
1336   d->cb = cb;
1337   d->cb_cls = cb_cls;
1338
1339   if (d->phase == SP_CONFIG_UPDATE)
1340   {
1341     GNUNET_SCHEDULER_cancel (d->task);
1342     d->phase = SP_START_DONE;
1343   }
1344   if (d->server != NULL)
1345   {
1346     GNUNET_CORE_disconnect (d->server);
1347     d->server = NULL;
1348   }
1349
1350   if (d->th != NULL)
1351   {
1352     GNUNET_TRANSPORT_get_hello_cancel (d->ghh);
1353     d->ghh = NULL;
1354     GNUNET_TRANSPORT_disconnect (d->th);
1355     d->th = NULL;
1356   }
1357   /* state clean up and notifications */
1358   GNUNET_free_non_null (d->hello);
1359
1360 #if DEBUG_TESTING
1361   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Terminating peer `%4s'\n"),
1362               GNUNET_i2s (&d->id));
1363 #endif
1364
1365   d->phase = SP_START_ARMING;
1366
1367   /* Check if this is a local or remote process */
1368   if (NULL != d->hostname)
1369   {
1370 #if DEBUG_TESTING
1371     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1372                 "Stopping gnunet-arm with config `%s' on host `%s'.\n",
1373                 d->cfgfile, d->hostname);
1374 #endif
1375
1376     if (d->username != NULL)
1377       GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
1378     else
1379       arg = GNUNET_strdup (d->hostname);
1380
1381     d->proc = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
1382 #if !DEBUG_TESTING
1383                                        "-q",
1384 #endif
1385                                        arg, "gnunet-arm",
1386 #if DEBUG_TESTING
1387                                        "-L", "DEBUG",
1388 #endif
1389                                        "-c", d->cfgfile, "-e", "-r", NULL);
1390     /* Use -r to restart arm and all services */
1391
1392     GNUNET_free (arg);
1393   }
1394   else
1395   {
1396 #if DEBUG_TESTING
1397     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1398                 "Stopping gnunet-arm with config `%s' locally.\n", d->cfgfile);
1399 #endif
1400     d->proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm", "gnunet-arm",
1401 #if DEBUG_TESTING
1402                                        "-L", "DEBUG",
1403 #endif
1404                                        "-c", d->cfgfile, "-e", "-r", NULL);
1405   }
1406
1407   GNUNET_free_non_null (del_arg);
1408   d->task =
1409       GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm, d);
1410
1411 }
1412
1413
1414 /**
1415  * Stops a GNUnet daemon.
1416  *
1417  * @param d the daemon that should be stopped
1418  * @param service the name of the service to stop
1419  * @param timeout how long to wait for process for shutdown to complete
1420  * @param cb function called once the daemon was stopped
1421  * @param cb_cls closure for cb
1422  */
1423 void
1424 GNUNET_TESTING_daemon_stop_service (struct GNUNET_TESTING_Daemon *d,
1425                                     const char *service,
1426                                     struct GNUNET_TIME_Relative timeout,
1427                                     GNUNET_TESTING_NotifyCompletion cb,
1428                                     void *cb_cls)
1429 {
1430   char *arg;
1431
1432   d->dead_cb = cb;
1433   d->dead_cb_cls = cb_cls;
1434
1435   GNUNET_assert (d->running == GNUNET_YES);
1436
1437   if (d->phase == SP_CONFIG_UPDATE)
1438   {
1439     GNUNET_SCHEDULER_cancel (d->task);
1440     d->phase = SP_START_DONE;
1441   }
1442
1443 #if DEBUG_TESTING
1444   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Terminating peer `%4s'\n"),
1445               GNUNET_i2s (&d->id));
1446 #endif
1447   if (d->churned_services != NULL)
1448   {
1449     d->dead_cb (d->dead_cb_cls, "A service has already been turned off!!");
1450     return;
1451   }
1452   d->phase = SP_SERVICE_SHUTDOWN_START;
1453   d->churned_services = GNUNET_strdup (service);
1454   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1455   /* Check if this is a local or remote process */
1456   if (NULL != d->hostname)
1457   {
1458 #if DEBUG_TESTING
1459     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1460                 "Stopping gnunet-arm with config `%s' on host `%s'.\n",
1461                 d->cfgfile, d->hostname);
1462 #endif
1463
1464     if (d->username != NULL)
1465       GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
1466     else
1467       arg = GNUNET_strdup (d->hostname);
1468
1469     d->proc = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
1470 #if !DEBUG_TESTING
1471                                        "-q",
1472 #endif
1473                                        arg, "gnunet-arm",
1474 #if DEBUG_TESTING
1475                                        "-L", "DEBUG",
1476 #endif
1477                                        "-c", d->cfgfile, "-k", service, "-q",
1478                                        "-T",
1479                                        GNUNET_TIME_relative_to_string (timeout),
1480                                        NULL);
1481     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1482                 "Stopping gnunet-arm with command ssh %s gnunet-arm -c %s -k %s -q\n",
1483                 arg, "gnunet-arm", d->cfgfile, service);
1484     GNUNET_free (arg);
1485   }
1486   else
1487   {
1488 #if DEBUG_TESTING
1489     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1490                 "Stopping gnunet-arm with config `%s' locally.\n", d->cfgfile);
1491 #endif
1492     d->proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm", "gnunet-arm",
1493 #if DEBUG_TESTING
1494                                        "-L", "DEBUG",
1495 #endif
1496                                        "-c", d->cfgfile, "-k", service, "-q",
1497                                        "-T",
1498                                        GNUNET_TIME_relative_to_string (timeout),
1499                                        NULL);
1500   }
1501
1502   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1503   d->task = GNUNET_SCHEDULER_add_now (&start_fsm, d);
1504 }
1505
1506
1507 /**
1508  * Stops a GNUnet daemon.
1509  *
1510  * @param d the daemon that should be stopped
1511  * @param timeout how long to wait for process for shutdown to complete
1512  * @param cb function called once the daemon was stopped
1513  * @param cb_cls closure for cb
1514  * @param delete_files GNUNET_YES to remove files, GNUNET_NO
1515  *        to leave them
1516  * @param allow_restart GNUNET_YES to restart peer later (using this API)
1517  *        GNUNET_NO to kill off and clean up for good
1518  */
1519 void
1520 GNUNET_TESTING_daemon_stop (struct GNUNET_TESTING_Daemon *d,
1521                             struct GNUNET_TIME_Relative timeout,
1522                             GNUNET_TESTING_NotifyCompletion cb, void *cb_cls,
1523                             int delete_files, int allow_restart)
1524 {
1525   char *arg;
1526   char *del_arg;
1527
1528   d->dead_cb = cb;
1529   d->dead_cb_cls = cb_cls;
1530
1531   if (NULL != d->cb)
1532   {
1533 #if DEBUG_TESTING
1534     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Setting d->dead on peer `%4s'\n"),
1535                 GNUNET_i2s (&d->id));
1536 #endif
1537     d->dead = GNUNET_YES;
1538     return;
1539   }
1540
1541   if ((d->running == GNUNET_NO) && (d->churn == GNUNET_YES))    /* Peer has already been stopped in churn context! */
1542   {
1543     /* Free what was left from churning! */
1544     GNUNET_assert (d->cfg != NULL);
1545     GNUNET_CONFIGURATION_destroy (d->cfg);
1546     if (delete_files == GNUNET_YES)
1547     {
1548       if (0 != UNLINK (d->cfgfile))
1549       {
1550         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "unlink");
1551       }
1552     }
1553     GNUNET_free (d->cfgfile);
1554     GNUNET_free_non_null (d->hostname);
1555     GNUNET_free_non_null (d->username);
1556     if (NULL != d->dead_cb)
1557       d->dead_cb (d->dead_cb_cls, NULL);
1558     GNUNET_free (d);
1559     return;
1560   }
1561
1562   del_arg = NULL;
1563   if (delete_files == GNUNET_YES)
1564   {
1565     GNUNET_asprintf (&del_arg, "-d");
1566   }
1567
1568   if (d->phase == SP_CONFIG_UPDATE)
1569   {
1570     GNUNET_SCHEDULER_cancel (d->task);
1571     d->phase = SP_START_DONE;
1572   }
1573   /** Move this call to scheduled shutdown as fix for CORE_connect calling daemon_stop?
1574   if (d->server != NULL)
1575     {
1576       GNUNET_CORE_disconnect (d->server);
1577       d->server = NULL;
1578     }
1579     */
1580   /* shutdown ARM process (will terminate others) */
1581 #if DEBUG_TESTING
1582   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Terminating peer `%4s'\n"),
1583               GNUNET_i2s (&d->id));
1584 #endif
1585   d->phase = SP_SHUTDOWN_START;
1586   d->running = GNUNET_NO;
1587   if (allow_restart == GNUNET_YES)
1588     d->churn = GNUNET_YES;
1589   if (d->th != NULL)
1590   {
1591     GNUNET_TRANSPORT_get_hello_cancel (d->ghh);
1592     d->ghh = NULL;
1593     GNUNET_TRANSPORT_disconnect (d->th);
1594     d->th = NULL;
1595   }
1596   /* Check if this is a local or remote process */
1597   if (NULL != d->hostname)
1598   {
1599 #if DEBUG_TESTING
1600     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1601                 "Stopping gnunet-arm with config `%s' on host `%s'.\n",
1602                 d->cfgfile, d->hostname);
1603 #endif
1604
1605     if (d->username != NULL)
1606       GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
1607     else
1608       arg = GNUNET_strdup (d->hostname);
1609
1610     d->proc = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
1611 #if !DEBUG_TESTING
1612                                        "-q",
1613 #endif
1614                                        arg, "gnunet-arm",
1615 #if DEBUG_TESTING
1616                                        "-L", "DEBUG",
1617 #endif
1618                                        "-c", d->cfgfile, "-e", "-q", "-T",
1619                                        GNUNET_TIME_relative_to_string (timeout),
1620                                        del_arg, NULL);
1621     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1622                 "Stopping gnunet-arm with command ssh %s gnunet-arm -c %s -e -q %s\n",
1623                 arg, "gnunet-arm", d->cfgfile, del_arg);
1624     /* Use -e to end arm, and -d to remove temp files */
1625     GNUNET_free (arg);
1626   }
1627   else
1628   {
1629 #if DEBUG_TESTING
1630     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1631                 "Stopping gnunet-arm with config `%s' locally.\n", d->cfgfile);
1632 #endif
1633     d->proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm", "gnunet-arm",
1634 #if DEBUG_TESTING
1635                                        "-L", "DEBUG",
1636 #endif
1637                                        "-c", d->cfgfile, "-e", "-q", "-T",
1638                                        GNUNET_TIME_relative_to_string (timeout),
1639                                        del_arg, NULL);
1640   }
1641
1642   GNUNET_free_non_null (del_arg);
1643   d->max_timeout = GNUNET_TIME_relative_to_absolute (timeout);
1644   d->task = GNUNET_SCHEDULER_add_now (&start_fsm, d);
1645 }
1646
1647
1648 /**
1649  * Changes the configuration of a GNUnet daemon.
1650  *
1651  * @param d the daemon that should be modified
1652  * @param cfg the new configuration for the daemon
1653  * @param cb function called once the configuration was changed
1654  * @param cb_cls closure for cb
1655  */
1656 void
1657 GNUNET_TESTING_daemon_reconfigure (struct GNUNET_TESTING_Daemon *d,
1658                                    struct GNUNET_CONFIGURATION_Handle *cfg,
1659                                    GNUNET_TESTING_NotifyCompletion cb,
1660                                    void *cb_cls)
1661 {
1662   char *arg;
1663
1664   if (d->phase != SP_START_DONE)
1665   {
1666     if (NULL != cb)
1667       cb (cb_cls,
1668           _
1669           ("Peer not yet running, can not change configuration at this point."));
1670     return;
1671   }
1672
1673   /* 1) write configuration to temporary file */
1674   if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, d->cfgfile))
1675   {
1676     if (NULL != cb)
1677       cb (cb_cls, _("Failed to write new configuration to disk."));
1678     return;
1679   }
1680
1681   /* 2) copy file to remote host (if necessary) */
1682   if (NULL == d->hostname)
1683   {
1684     /* signal success */
1685     if (NULL != cb)
1686       cb (cb_cls, NULL);
1687     return;
1688   }
1689 #if DEBUG_TESTING
1690   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1691               "Copying updated configuration file to remote host `%s'.\n",
1692               d->hostname);
1693 #endif
1694   d->phase = SP_CONFIG_UPDATE;
1695   if (NULL != d->username)
1696     GNUNET_asprintf (&arg, "%s@%s:%s", d->username, d->hostname, d->cfgfile);
1697   else
1698     GNUNET_asprintf (&arg, "%s:%s", d->hostname, d->cfgfile);
1699   d->proc = GNUNET_OS_start_process (NULL, NULL, "scp", "scp",
1700 #if !DEBUG_TESTING
1701                                      "-q",
1702 #endif
1703                                      d->cfgfile, arg, NULL);
1704   GNUNET_free (arg);
1705   if (NULL == d->proc)
1706   {
1707     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1708                 _("Could not start `%s' process to copy configuration file.\n"),
1709                 "scp");
1710     if (NULL != cb)
1711       cb (cb_cls, _("Failed to copy new configuration to remote machine."));
1712     d->phase = SP_START_DONE;
1713     return;
1714   }
1715   d->update_cb = cb;
1716   d->update_cb_cls = cb_cls;
1717   d->task =
1718       GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT, &start_fsm, d);
1719 }
1720
1721
1722 /**
1723  * Data kept for each pair of peers that we try
1724  * to connect.
1725  */
1726 struct GNUNET_TESTING_ConnectContext
1727 {
1728   /**
1729    * Testing handle to the first daemon.
1730    */
1731   struct GNUNET_TESTING_Daemon *d1;
1732
1733   /**
1734    * Handle to core of first daemon (to check connect)
1735    */
1736   struct GNUNET_CORE_Handle *d1core;
1737
1738   /**
1739    * Have we actually connected to the core of the first daemon yet?
1740    */
1741   int d1core_ready;
1742
1743   /**
1744    * Testing handle to the second daemon.
1745    */
1746   struct GNUNET_TESTING_Daemon *d2;
1747
1748   /**
1749    * Transport handle to the first daemon (to offer the HELLO of the second daemon to).
1750    */
1751   struct GNUNET_TRANSPORT_Handle *d1th;
1752
1753   /**
1754    * Function to call once we are done (or have timed out).
1755    */
1756   GNUNET_TESTING_NotifyConnection cb;
1757
1758   /**
1759    * Closure for "nb".
1760    */
1761   void *cb_cls;
1762
1763   /**
1764    * The relative timeout from whence this connect attempt was
1765    * started.  Allows for reconnect attempts.
1766    */
1767   struct GNUNET_TIME_Relative relative_timeout;
1768
1769   /**
1770    * Maximum number of connect attempts, will retry connection
1771    * this number of times on failures.
1772    */
1773   unsigned int connect_attempts;
1774
1775   /**
1776    * Hello timeout task
1777    */
1778   GNUNET_SCHEDULER_TaskIdentifier hello_send_task;
1779
1780   /**
1781    * Connect timeout task
1782    */
1783   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
1784
1785   /**
1786    * When should this operation be complete (or we must trigger
1787    * a timeout).
1788    */
1789   struct GNUNET_TIME_Relative timeout_hello;
1790
1791   /**
1792    * Was the connection attempt successful?
1793    */
1794   int connected;
1795
1796   /**
1797    * When connecting, do we need to send the HELLO?
1798    */
1799   int send_hello;
1800
1801   /**
1802    * The distance between the two connected peers
1803    */
1804   uint32_t distance;
1805 };
1806
1807
1808 /** Forward declaration **/
1809 static void
1810 reattempt_daemons_connect (void *cls,
1811                            const struct GNUNET_SCHEDULER_TaskContext *tc);
1812
1813
1814 /**
1815  * Notify callback about success or failure of the attempt
1816  * to connect the two peers
1817  *
1818  * @param cls our "struct GNUNET_TESTING_ConnectContext" (freed)
1819  * @param tc reason tells us if we succeeded or failed
1820  */
1821 static void
1822 notify_connect_result (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1823 {
1824   struct GNUNET_TESTING_ConnectContext *ctx = cls;
1825
1826   ctx->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1827   if (ctx->hello_send_task != GNUNET_SCHEDULER_NO_TASK)
1828   {
1829     GNUNET_SCHEDULER_cancel (ctx->hello_send_task);
1830     ctx->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
1831   }
1832
1833   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
1834   {
1835     if (ctx->d1th != NULL)
1836       GNUNET_TRANSPORT_disconnect (ctx->d1th);
1837     ctx->d1th = NULL;
1838     if (ctx->d1core != NULL)
1839       GNUNET_CORE_disconnect (ctx->d1core);
1840     ctx->d1core = NULL;
1841     GNUNET_free (ctx);
1842     return;
1843   }
1844
1845   if (ctx->d1th != NULL)
1846     GNUNET_TRANSPORT_disconnect (ctx->d1th);
1847   ctx->d1th = NULL;
1848   if (ctx->d1core != NULL)
1849     GNUNET_CORE_disconnect (ctx->d1core);
1850   ctx->d1core = NULL;
1851
1852   if (ctx->connected == GNUNET_YES)
1853   {
1854     if (ctx->cb != NULL)
1855     {
1856       ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, ctx->distance,
1857                ctx->d1->cfg, ctx->d2->cfg, ctx->d1, ctx->d2, NULL);
1858     }
1859   }
1860   else if (ctx->connect_attempts > 0)
1861   {
1862     ctx->d1core_ready = GNUNET_NO;
1863     ctx->timeout_task =
1864         GNUNET_SCHEDULER_add_now (&reattempt_daemons_connect, ctx);
1865     return;
1866   }
1867   else
1868   {
1869     if (ctx->cb != NULL)
1870     {
1871       ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg,
1872                ctx->d2->cfg, ctx->d1, ctx->d2, _("Peers failed to connect"));
1873     }
1874   }
1875   GNUNET_free (ctx);
1876 }
1877
1878
1879 /**
1880  * Success, connection is up.  Signal client our success.
1881  *
1882  * @param cls our "struct GNUNET_TESTING_ConnectContext"
1883  * @param peer identity of the peer that has connected
1884  * @param atsi performance information
1885  *
1886  */
1887 static void
1888 connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer,
1889                 const struct GNUNET_ATS_Information *atsi)
1890 {
1891   struct GNUNET_TESTING_ConnectContext *ctx = cls;
1892
1893 #if DEBUG_TESTING
1894   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected peer %s to peer %s\n",
1895               ctx->d1->shortname, GNUNET_i2s (peer));
1896 #endif
1897
1898   if (0 != memcmp (&ctx->d2->id, peer, sizeof (struct GNUNET_PeerIdentity)))
1899     return;
1900   ctx->connected = GNUNET_YES;
1901   ctx->distance = 0;            /* FIXME: distance */
1902   if (ctx->hello_send_task != GNUNET_SCHEDULER_NO_TASK)
1903   {
1904     GNUNET_SCHEDULER_cancel (ctx->hello_send_task);
1905     ctx->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
1906   }
1907   GNUNET_SCHEDULER_cancel (ctx->timeout_task);
1908   ctx->timeout_task = GNUNET_SCHEDULER_add_now (&notify_connect_result, ctx);
1909 }
1910
1911
1912 static void
1913 send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1914 {
1915   struct GNUNET_TESTING_ConnectContext *ctx = cls;
1916   struct GNUNET_MessageHeader *hello;
1917
1918   ctx->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
1919   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
1920     return;
1921   if ((ctx->d1core_ready == GNUNET_YES) && (ctx->d2->hello != NULL) &&
1922       (NULL != GNUNET_HELLO_get_header (ctx->d2->hello)) &&
1923       (ctx->d1->phase == SP_START_DONE) && (ctx->d2->phase == SP_START_DONE))
1924   {
1925     hello = GNUNET_HELLO_get_header (ctx->d2->hello);
1926     GNUNET_assert (hello != NULL);
1927 #if DEBUG_TESTING
1928     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Offering hello of %s to %s\n",
1929                 ctx->d2->shortname, ctx->d1->shortname);
1930 #endif
1931     GNUNET_TRANSPORT_offer_hello (ctx->d1th, hello, NULL, NULL);
1932     GNUNET_assert (ctx->d1core != NULL);
1933 #if DEBUG_TESTING
1934     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1935                 "Sending connect request to TRANSPORT of %s for peer %s\n",
1936                 GNUNET_i2s (&ctx->d1->id),
1937                 GNUNET_h2s (&ctx->d2->id.hashPubKey));
1938 #endif
1939     GNUNET_TRANSPORT_try_connect (ctx->d1th, &ctx->d2->id);
1940     ctx->timeout_hello =
1941         GNUNET_TIME_relative_add (ctx->timeout_hello,
1942                                   GNUNET_TIME_relative_multiply
1943                                   (GNUNET_TIME_UNIT_MILLISECONDS, 500));
1944   }
1945   ctx->hello_send_task =
1946       GNUNET_SCHEDULER_add_delayed (ctx->timeout_hello, &send_hello, ctx);
1947 }
1948
1949 /**
1950  * Notify of a successful connection to the core service.
1951  *
1952  * @param cls a ConnectContext
1953  * @param server handle to the core service
1954  * @param my_identity the peer identity of this peer
1955  */
1956 void
1957 core_init_notify (void *cls, struct GNUNET_CORE_Handle *server,
1958                   const struct GNUNET_PeerIdentity *my_identity)
1959 {
1960   struct GNUNET_TESTING_ConnectContext *connect_ctx = cls;
1961
1962   connect_ctx->d1core_ready = GNUNET_YES;
1963
1964   if (connect_ctx->send_hello == GNUNET_NO)
1965   {
1966     GNUNET_TRANSPORT_try_connect (connect_ctx->d1th,
1967                                   &connect_ctx->d2->id);
1968 #if DEBUG_TESTING
1969     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1970                 "Sending connect request to TRANSPORT of %s for peer %s\n",
1971                 connect_ctx->d1->shortname, connect_ctx->d2->shortname);
1972 #endif
1973   }
1974
1975 }
1976
1977
1978 static void
1979 reattempt_daemons_connect (void *cls,
1980                            const struct GNUNET_SCHEDULER_TaskContext *tc)
1981 {
1982   struct GNUNET_TESTING_ConnectContext *ctx = cls;
1983
1984   ctx->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1985   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
1986     return;
1987 #if DEBUG_TESTING_RECONNECT
1988   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1989               "re-attempting connect of peer %s to peer %s\n",
1990               ctx->d1->shortname, ctx->d2->shortname);
1991 #endif
1992   ctx->connect_attempts--;
1993   GNUNET_assert (ctx->d1core == NULL);
1994   ctx->d1core_ready = GNUNET_NO;
1995   ctx->d1core =
1996       GNUNET_CORE_connect (ctx->d1->cfg, 1, ctx, &core_init_notify,
1997                            &connect_notify, NULL, NULL, GNUNET_NO, NULL,
1998                            GNUNET_NO, no_handlers);
1999   if (ctx->d1core == NULL)
2000   {
2001     if (NULL != ctx->cb)
2002       ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg,
2003                ctx->d2->cfg, ctx->d1, ctx->d2,
2004                _("Failed to connect to core service of first peer!\n"));
2005     GNUNET_free (ctx);
2006     return;
2007   }
2008
2009   /* Don't know reason for initial connect failure, update the HELLO for the second peer */
2010   if (NULL != ctx->d2->hello)
2011   {
2012     GNUNET_free (ctx->d2->hello);
2013     ctx->d2->hello = NULL;
2014     if (NULL != ctx->d2->th)
2015     {
2016       GNUNET_TRANSPORT_get_hello_cancel (ctx->d2->ghh);
2017       ctx->d2->ghh = NULL;
2018       GNUNET_TRANSPORT_disconnect (ctx->d2->th);
2019     }
2020     ctx->d2->th =
2021         GNUNET_TRANSPORT_connect (ctx->d2->cfg, &ctx->d2->id, NULL, NULL, NULL,
2022                                   NULL);
2023     GNUNET_assert (ctx->d2->th != NULL);
2024     ctx->d2->ghh =
2025         GNUNET_TRANSPORT_get_hello (ctx->d2->th, &process_hello, ctx->d2);
2026   }
2027
2028   if ((NULL == ctx->d2->hello) && (ctx->d2->th == NULL))
2029   {
2030     ctx->d2->th =
2031         GNUNET_TRANSPORT_connect (ctx->d2->cfg, &ctx->d2->id, NULL, NULL, NULL,
2032                                   NULL);
2033     if (ctx->d2->th == NULL)
2034     {
2035       GNUNET_CORE_disconnect (ctx->d1core);
2036       GNUNET_free (ctx);
2037       if (NULL != ctx->cb)
2038         ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg,
2039                  ctx->d2->cfg, ctx->d1, ctx->d2,
2040                  _("Failed to connect to transport service!\n"));
2041       return;
2042     }
2043     ctx->d2->ghh =
2044         GNUNET_TRANSPORT_get_hello (ctx->d2->th, &process_hello, ctx->d2);
2045   }
2046
2047   if (ctx->send_hello == GNUNET_YES)
2048   {
2049     ctx->d1th =
2050         GNUNET_TRANSPORT_connect (ctx->d1->cfg, &ctx->d1->id, ctx->d1, NULL,
2051                                   NULL, NULL);
2052     if (ctx->d1th == NULL)
2053     {
2054       GNUNET_CORE_disconnect (ctx->d1core);
2055       GNUNET_free (ctx);
2056       if (NULL != ctx->cb)
2057         ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg,
2058                  ctx->d2->cfg, ctx->d1, ctx->d2,
2059                  _("Failed to connect to transport service!\n"));
2060       return;
2061     }
2062     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == ctx->hello_send_task);
2063     ctx->hello_send_task = GNUNET_SCHEDULER_add_now (&send_hello, ctx);
2064   }
2065   else
2066   {
2067     GNUNET_TRANSPORT_try_connect (ctx->d1th, &ctx->d2->id);
2068   }
2069   ctx->timeout_task =
2070       GNUNET_SCHEDULER_add_delayed (ctx->relative_timeout,
2071                                     &notify_connect_result, ctx);
2072 }
2073
2074 /**
2075  * Iterator for currently known peers, to ensure
2076  * that we don't try to send duplicate connect
2077  * requests to core.
2078  *
2079  * @param cls our "struct GNUNET_TESTING_ConnectContext"
2080  * @param peer identity of the peer that has connected,
2081  *        NULL when iteration has finished
2082  * @param atsi performance information
2083  *
2084  */
2085 static void
2086 core_initial_iteration (void *cls, const struct GNUNET_PeerIdentity *peer,
2087                         const struct GNUNET_ATS_Information *atsi)
2088 {
2089   struct GNUNET_TESTING_ConnectContext *ctx = cls;
2090
2091   if ((peer != NULL) &&
2092       (0 == memcmp (&ctx->d2->id, peer, sizeof (struct GNUNET_PeerIdentity))))
2093   {
2094     ctx->connected = GNUNET_YES;
2095     ctx->distance = 0;          /* FIXME: distance */
2096     return;
2097   }
2098   if (peer != NULL)
2099     return;                     /* ignore other peers */
2100   /* peer == NULL: End of iteration over peers */
2101
2102   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == ctx->timeout_task);
2103   if (ctx->connected == GNUNET_YES)
2104   {
2105     ctx->timeout_task = GNUNET_SCHEDULER_add_now (&notify_connect_result, ctx);
2106     return;
2107   }
2108
2109   /* Peer not already connected, need to schedule connect request! */
2110   if (ctx->d1core == NULL)
2111   {
2112 #if DEBUG_TESTING
2113     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2114                 "Peers are NOT connected, connecting to core!\n");
2115 #endif
2116     ctx->d1core =
2117         GNUNET_CORE_connect (ctx->d1->cfg, 1, ctx, &core_init_notify,
2118                              &connect_notify, NULL, NULL, GNUNET_NO, NULL,
2119                              GNUNET_NO, no_handlers);
2120   }
2121
2122   if (ctx->d1core == NULL)
2123   {
2124     ctx->timeout_task = GNUNET_SCHEDULER_add_now (&notify_connect_result, ctx);
2125     return;
2126   }
2127
2128   if ((NULL == ctx->d2->hello) && (ctx->d2->th == NULL))        /* Do not yet have the second peer's hello, set up a task to get it */
2129   {
2130     ctx->d2->th =
2131         GNUNET_TRANSPORT_connect (ctx->d2->cfg, &ctx->d2->id, NULL, NULL, NULL,
2132                                   NULL);
2133     if (ctx->d2->th == NULL)
2134     {
2135       GNUNET_CORE_disconnect (ctx->d1core);
2136       ctx->d1core = NULL;
2137       ctx->timeout_task =
2138           GNUNET_SCHEDULER_add_now (&notify_connect_result, ctx);
2139       return;
2140     }
2141     ctx->d2->ghh =
2142         GNUNET_TRANSPORT_get_hello (ctx->d2->th, &process_hello, ctx->d2);
2143   }
2144
2145   if (ctx->send_hello == GNUNET_YES)
2146   {
2147     ctx->d1th =
2148         GNUNET_TRANSPORT_connect (ctx->d1->cfg, &ctx->d1->id, ctx->d1, NULL,
2149                                   NULL, NULL);
2150     if (ctx->d1th == NULL)
2151     {
2152       GNUNET_CORE_disconnect (ctx->d1core);
2153       ctx->d1core = NULL;
2154       ctx->timeout_task =
2155           GNUNET_SCHEDULER_add_now (&notify_connect_result, ctx);
2156       return;
2157     }
2158     GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == ctx->hello_send_task);
2159     ctx->hello_send_task = GNUNET_SCHEDULER_add_now (&send_hello, ctx);
2160   }
2161
2162   ctx->timeout_task =
2163       GNUNET_SCHEDULER_add_delayed (ctx->relative_timeout,
2164                                     &notify_connect_result, ctx);
2165
2166 }
2167
2168
2169 /**
2170  * Establish a connection between two GNUnet daemons.  The daemons
2171  * must both be running and not be stopped until either the
2172  * 'cb' callback is called OR the connection request has been
2173  * explicitly cancelled.
2174  *
2175  * @param d1 handle for the first daemon
2176  * @param d2 handle for the second daemon
2177  * @param timeout how long is the connection attempt
2178  *        allowed to take?
2179  * @param max_connect_attempts how many times should we try to reconnect
2180  *        (within timeout)
2181  * @param send_hello GNUNET_YES to send the HELLO, GNUNET_NO to assume
2182  *                   the HELLO has already been exchanged
2183  * @param cb function to call at the end
2184  * @param cb_cls closure for cb
2185  * @return handle to cancel the request
2186  */
2187 struct GNUNET_TESTING_ConnectContext *
2188 GNUNET_TESTING_daemons_connect (struct GNUNET_TESTING_Daemon *d1,
2189                                 struct GNUNET_TESTING_Daemon *d2,
2190                                 struct GNUNET_TIME_Relative timeout,
2191                                 unsigned int max_connect_attempts,
2192                                 int send_hello,
2193                                 GNUNET_TESTING_NotifyConnection cb,
2194                                 void *cb_cls)
2195 {
2196   struct GNUNET_TESTING_ConnectContext *ctx;
2197
2198   if ((d1->running == GNUNET_NO) || (d2->running == GNUNET_NO))
2199   {
2200     if (NULL != cb)
2201       cb (cb_cls, &d1->id, &d2->id, 0, d1->cfg, d2->cfg, d1, d2,
2202           _("Peers are not fully running yet, can not connect!\n"));
2203     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Peers are not up!\n");
2204     return NULL;
2205   }
2206
2207   ctx = GNUNET_malloc (sizeof (struct GNUNET_TESTING_ConnectContext));
2208   ctx->d1 = d1;
2209   ctx->d2 = d2;
2210   ctx->timeout_hello =
2211       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500);
2212   ctx->relative_timeout =
2213       GNUNET_TIME_relative_divide (timeout, max_connect_attempts);
2214   ctx->cb = cb;
2215   ctx->cb_cls = cb_cls;
2216   ctx->connect_attempts = max_connect_attempts;
2217   ctx->connected = GNUNET_NO;
2218   ctx->send_hello = send_hello;
2219 #if DEBUG_TESTING
2220   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asked to connect peer %s to peer %s\n",
2221               d1->shortname, d2->shortname);
2222 #endif
2223
2224   /* Core is up! Iterate over all _known_ peers first to check if we are already connected to the peer! */
2225   GNUNET_assert (GNUNET_OK ==
2226                  GNUNET_CORE_is_peer_connected (ctx->d1->cfg, &ctx->d2->id,
2227                                                 &core_initial_iteration, ctx));
2228   return ctx;
2229 }
2230
2231
2232 /**
2233  * Cancel an attempt to connect two daemons.
2234  *
2235  * @param cc connect context
2236  */
2237 void
2238 GNUNET_TESTING_daemons_connect_cancel (struct GNUNET_TESTING_ConnectContext *cc)
2239 {
2240   if (GNUNET_SCHEDULER_NO_TASK != cc->timeout_task)
2241   {
2242     GNUNET_SCHEDULER_cancel (cc->timeout_task);
2243     cc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2244   }
2245   if (GNUNET_SCHEDULER_NO_TASK != cc->hello_send_task)
2246   {
2247     GNUNET_SCHEDULER_cancel (cc->hello_send_task);
2248     cc->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
2249   }
2250   if (NULL != cc->d1core)
2251   {
2252     GNUNET_CORE_disconnect (cc->d1core);
2253     cc->d1core = NULL;
2254   }
2255   if (NULL != cc->d1th)
2256   {
2257     GNUNET_TRANSPORT_disconnect (cc->d1th);
2258     cc->d1th = NULL;
2259   }
2260   GNUNET_free (cc);
2261 }
2262
2263
2264 /* end of testing.c */