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_NO
  41 #define DEBUG_TESTING_RECONNECT GNUNET_NO
  42
  43 /**
  44  * How long do we wait after starting gnunet-service-arm
  45  * for the core service to be alive?
  46  */
  47 #define ARM_START_WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
  48
  49 /**
  50  * How many times are we willing to try to wait for "scp" or
  51  * "gnunet-service-arm" to complete (waitpid) before giving up?
  52  */
  53 #define MAX_EXEC_WAIT_RUNS 250
  54
  55 static struct GNUNET_CORE_MessageHandler no_handlers[] = { {NULL, 0, 0} };
  56
  57 /**
  58  * Receive the HELLO from one peer, give it to the other
  59  * and ask them to connect.
  60  *
  61  * @param cls "struct ConnectContext"
  62  * @param message HELLO message of peer
  63  */
  64 static void
  65 process_hello (void *cls, const struct GNUNET_MessageHeader *message)
  66 {
  67   struct GNUNET_TESTING_Daemon *daemon = cls;
  68   int msize;
  69   if (daemon == NULL)
  70     return;
  71
  72   if (daemon->server != NULL)
  73     {
  74       GNUNET_CORE_disconnect(daemon->server);
  75       daemon->server = NULL;
  76     }
  77
  78   GNUNET_assert (message != NULL);
  79   msize = ntohs(message->size);
  80   if (msize < 1)
  81     {
  82       return;
  83     }
  84   if (daemon->th != NULL)
  85     {
  86       GNUNET_TRANSPORT_get_hello_cancel(daemon->th, &process_hello, daemon);
  87     }
  88 #if DEBUG_TESTING
  89   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  90               "Received `%s' from transport service of `%4s'\n",
  91               "HELLO", GNUNET_i2s (&daemon->id));
  92 #endif
  93
  94
  95
  96     {
  97       GNUNET_free_non_null(daemon->hello);
  98       daemon->hello = GNUNET_malloc(msize);
  99       memcpy(daemon->hello, message, msize);
 100
 101       if (daemon->th != NULL)
 102         {
 103           GNUNET_TRANSPORT_disconnect(daemon->th);
 104           daemon->th = NULL;
 105         }
 106     }
 107
 108 }
 109
 110 /**
 111  * Function called after GNUNET_CORE_connect has succeeded
 112  * (or failed for good).  Note that the private key of the
 113  * peer is intentionally not exposed here; if you need it,
 114  * your process should try to read the private key file
 115  * directly (which should work if you are authorized...).
 116  *
 117  * @param cls closure
 118  * @param server handle to the server, NULL if we failed
 119  * @param my_identity ID of this peer, NULL if we failed
 120  * @param publicKey public key of this peer, NULL if we failed
 121  */
 122 static void
 123 testing_init (void *cls,
 124               struct GNUNET_CORE_Handle *server,
 125               const struct GNUNET_PeerIdentity *my_identity,
 126               const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 127 {
 128   struct GNUNET_TESTING_Daemon *d = cls;
 129   GNUNET_TESTING_NotifyDaemonRunning cb;
 130
 131   GNUNET_assert (d->phase == SP_START_CORE);
 132   d->phase = SP_START_DONE;
 133   cb = d->cb;
 134   d->cb = NULL;
 135   if (server == NULL)
 136     {
 137       d->server = NULL;
 138       if (GNUNET_YES == d->dead)
 139         GNUNET_TESTING_daemon_stop (d, GNUNET_TIME_absolute_get_remaining(d->max_timeout), d->dead_cb, d->dead_cb_cls, GNUNET_YES, GNUNET_NO);
 140       else if (NULL != cb)
 141         cb (d->cb_cls, NULL, d->cfg, d,
 142             _("Failed to connect to core service\n"));
 143       return;
 144     }
 145 #if DEBUG_TESTING
 146   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 147               "Successfully started peer `%4s'.\n", GNUNET_i2s (my_identity));
 148 #endif
 149   d->id = *my_identity;
 150   d->shortname = strdup (GNUNET_i2s (my_identity));
 151   d->server = server;
 152   d->running = GNUNET_YES;
 153   if (GNUNET_YES == d->dead)
 154     GNUNET_TESTING_daemon_stop (d, GNUNET_TIME_absolute_get_remaining(d->max_timeout), d->dead_cb, d->dead_cb_cls, GNUNET_YES, GNUNET_NO);
 155   else if (NULL != cb)
 156     cb (d->cb_cls, my_identity, d->cfg, d, NULL);
 157 #if DEBUG_TESTING
 158   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 159               "Successfully started peer `%4s'.\n", GNUNET_i2s (my_identity));
 160 #endif
 161
 162
 163   d->th = GNUNET_TRANSPORT_connect (d->sched,
 164                                     d->cfg,
 165                                     &d->id,
 166                                     d, NULL, NULL, NULL);
 167   if (d->th == NULL)
 168     {
 169       if (GNUNET_YES == d->dead)
 170         GNUNET_TESTING_daemon_stop (d, GNUNET_TIME_absolute_get_remaining(d->max_timeout), d->dead_cb, d->dead_cb_cls, GNUNET_YES, GNUNET_NO);
 171       else if (NULL != d->cb)
 172         d->cb (d->cb_cls, &d->id, d->cfg, d,
 173             _("Failed to connect to transport service!\n"));
 174       return;
 175     }
 176
 177   GNUNET_TRANSPORT_get_hello (d->th, &process_hello, d);
 178 }
 179
 180
 181 /**
 182  * Finite-state machine for starting GNUnet.
 183  *
 184  * @param cls our "struct GNUNET_TESTING_Daemon"
 185  * @param tc unused
 186  */
 187 static void
 188 start_fsm (void *cls,
 189            const struct GNUNET_SCHEDULER_TaskContext *tc)
 190 {
 191   struct GNUNET_TESTING_Daemon *d = cls;
 192   GNUNET_TESTING_NotifyDaemonRunning cb;
 193   enum GNUNET_OS_ProcessStatusType type;
 194   unsigned long code;
 195   char *dst;
 196   int bytes_read;
 197
 198 #if DEBUG_TESTING
 199   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 200               "Peer FSM is in phase %u.\n", d->phase);
 201 #endif
 202
 203   d->task = GNUNET_SCHEDULER_NO_TASK;
 204   switch (d->phase)
 205     {
 206     case SP_COPYING:
 207       /* confirm copying complete */
 208       if (GNUNET_OK != GNUNET_OS_process_status (d->pid, &type, &code))
 209         {
 210           if (GNUNET_TIME_absolute_get_remaining(d->max_timeout).value == 0)
 211             {
 212               cb = d->cb;
 213               d->cb = NULL;
 214               if (NULL != cb)
 215                 cb (d->cb_cls,
 216                     NULL,
 217                     d->cfg, d, _("`scp' does not seem to terminate (timeout copying config).\n"));
 218               return;
 219             }
 220           /* wait some more */
 221           d->task
 222             = GNUNET_SCHEDULER_add_delayed (d->sched,
 223                                             GNUNET_CONSTANTS_EXEC_WAIT,
 224                                             &start_fsm, d);
 225           return;
 226         }
 227       if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 228         {
 229           cb = d->cb;
 230           d->cb = NULL;
 231           if (NULL != cb)
 232             cb (d->cb_cls,
 233                 NULL, d->cfg, d, _("`scp' did not complete cleanly.\n"));
 234           return;
 235         }
 236 #if DEBUG_TESTING
 237       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 238                   "Successfully copied configuration file.\n");
 239 #endif
 240       d->phase = SP_COPIED;
 241       /* fall-through */
 242     case SP_COPIED:
 243       /* Start create hostkey process */
 244       d->pipe_stdout = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES);
 245       if (d->pipe_stdout == NULL)
 246         {
 247           cb = d->cb;
 248           d->cb = NULL;
 249           if (NULL != cb)
 250             cb (d->cb_cls,
 251                 NULL,
 252                 d->cfg,
 253                 d,
 254                 (NULL == d->hostname)
 255                 ? _("Failed to create pipe for `gnunet-peerinfo' process.\n")
 256                 : _("Failed to create pipe for `ssh' process.\n"));
 257           return;
 258         }
 259       if (NULL == d->hostname)
 260         {
 261 #if DEBUG_TESTING
 262           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 263                       "Starting `%s', with command `%s %s %s %s'.\n",
 264                       "gnunet-peerinfo", "gnunet-peerinfo", "-c", d->cfgfile,
 265                       "-sq");
 266 #endif
 267           d->pid = GNUNET_OS_start_process (NULL, d->pipe_stdout, "gnunet-peerinfo",
 268                                             "gnunet-peerinfo",
 269                                             "-c", d->cfgfile,
 270                                             "-sq", NULL);
 271           GNUNET_DISK_pipe_close_end(d->pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
 272         }
 273       else
 274         {
 275           if (d->username != NULL)
 276             GNUNET_asprintf (&dst, "%s@%s", d->username, d->hostname);
 277           else
 278             dst = GNUNET_strdup (d->hostname);
 279
 280 #if DEBUG_TESTING
 281           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 282                       "Starting `%s', with command `%s %s %s %s %s %s'.\n",
 283                       "gnunet-peerinfo", "ssh", dst, "gnunet-peerinfo", "-c", d->cfgfile,
 284                       "-sq");
 285 #endif
 286           if (d->ssh_port_str == NULL)
 287             {
 288               d->pid = GNUNET_OS_start_process (NULL, d->pipe_stdout, "ssh",
 289                                                 "ssh",
 290 #if !DEBUG_TESTING
 291                                                 "-q",
 292 #endif
 293                                                 dst,
 294                                                 "gnunet-peerinfo",
 295                                                 "-c", d->cfgfile, "-sq", NULL);
 296             }
 297           else
 298             {
 299               d->pid = GNUNET_OS_start_process (NULL, d->pipe_stdout, "ssh",
 300                                                 "ssh", "-p", d->ssh_port_str,
 301 #if !DEBUG_TESTING
 302                                                 "-q",
 303 #endif
 304                                                 dst,
 305                                                 "gnunet-peerinfo",
 306                                                 "-c", d->cfgfile, "-sq", NULL);
 307             }
 308           GNUNET_DISK_pipe_close_end(d->pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
 309           GNUNET_free (dst);
 310         }
 311       if (-1 == d->pid)
 312         {
 313           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 314                       _("Could not start `%s' process to create hostkey.\n"),
 315                       (NULL == d->hostname) ? "gnunet-peerinfo" : "ssh");
 316           cb = d->cb;
 317           d->cb = NULL;
 318           if (NULL != cb)
 319             cb (d->cb_cls,
 320                 NULL,
 321                 d->cfg,
 322                 d,
 323                 (NULL == d->hostname)
 324                 ? _("Failed to start `gnunet-peerinfo' process.\n")
 325                 : _("Failed to start `ssh' process.\n"));
 326           GNUNET_DISK_pipe_close(d->pipe_stdout);
 327           return;
 328         }
 329 #if DEBUG_TESTING
 330       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 331                   "Started `%s', waiting for hostkey.\n",
 332                   "gnunet-peerinfo");
 333 #endif
 334       d->phase = SP_HOSTKEY_CREATE;
 335       d->task
 336         = GNUNET_SCHEDULER_add_read_file (d->sched,
 337                                           GNUNET_TIME_absolute_get_remaining(d->max_timeout),
 338                                           GNUNET_DISK_pipe_handle(d->pipe_stdout,
 339                                                                   GNUNET_DISK_PIPE_END_READ),
 340                                           &start_fsm,
 341                                           d);
 342       break;
 343     case SP_HOSTKEY_CREATE:
 344       bytes_read = GNUNET_DISK_file_read(GNUNET_DISK_pipe_handle(d->pipe_stdout,
 345                                                                  GNUNET_DISK_PIPE_END_READ),
 346                                          &d->hostkeybuf[d->hostkeybufpos],
 347                                          sizeof(d->hostkeybuf) - d->hostkeybufpos);
 348       if (bytes_read > 0)
 349         d->hostkeybufpos += bytes_read;
 350
 351       if ( (d->hostkeybufpos < 104) &&
 352            (bytes_read > 0) )
 353         {
 354           /* keep reading */
 355           d->task
 356             = GNUNET_SCHEDULER_add_read_file (d->sched,
 357                                               GNUNET_TIME_absolute_get_remaining(d->max_timeout),
 358                                               GNUNET_DISK_pipe_handle(d->pipe_stdout,
 359                                                                       GNUNET_DISK_PIPE_END_READ),
 360                                               &start_fsm,
 361                                               d);
 362           return;
 363         }
 364       d->hostkeybuf[103] = '\0';
 365       if ( (bytes_read < 0) ||
 366            (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (d->hostkeybuf,
 367                                                          &d->id.hashPubKey)) )
 368         {
 369           /* error */
 370           if (bytes_read < 0)
 371             GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 372                        _("Error reading from gnunet-peerinfo: %s\n"),
 373                        STRERROR (errno));
 374           else
 375             GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
 376                        _("Malformed output from gnunet-peerinfo!\n"));
 377           cb = d->cb;
 378           d->cb = NULL;
 379           GNUNET_DISK_pipe_close(d->pipe_stdout);
 380           d->pipe_stdout = NULL;
 381           (void) PLIBC_KILL (d->pid, SIGKILL);
 382           GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (d->pid));
 383           d->pid = 0;
 384           if (NULL != cb)
 385             cb (d->cb_cls,
 386                 NULL,
 387                 d->cfg,
 388                 d,
 389                 _("`Failed to get hostkey!\n"));
 390           return;
 391         }
 392       GNUNET_DISK_pipe_close(d->pipe_stdout);
 393       d->pipe_stdout = NULL;
 394       (void) PLIBC_KILL (d->pid, SIGKILL);
 395       GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (d->pid));
 396       d->pid = 0;
 397 #if DEBUG_TESTING
 398       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 399                   "Successfully got hostkey!\n");
 400 #endif
 401       if (d->hostkey_callback != NULL)
 402         {
 403           d->hostkey_callback(d->hostkey_cls, &d->id, d, NULL);
 404           d->phase = SP_HOSTKEY_CREATED;
 405         }
 406       else
 407         {
 408           d->phase = SP_TOPOLOGY_SETUP;
 409         }
 410       /* Fall through */
 411     case SP_HOSTKEY_CREATED:
 412       /* wait for topology finished */
 413       if ((GNUNET_YES == d->dead) || (GNUNET_TIME_absolute_get_remaining(d->max_timeout).value == 0))
 414         {
 415           cb = d->cb;
 416           d->cb = NULL;
 417           if (NULL != cb)
 418             cb (d->cb_cls,
 419                 NULL,
 420                 d->cfg,
 421                 d,
 422                 _("`Failed while waiting for topology setup!\n"));
 423           return;
 424         }
 425
 426       d->task
 427         = GNUNET_SCHEDULER_add_delayed (d->sched,
 428                                         GNUNET_CONSTANTS_EXEC_WAIT,
 429                                         &start_fsm, d);
 430       break;
 431     case SP_TOPOLOGY_SETUP:
 432       /* start GNUnet on remote host */
 433       if (NULL == d->hostname)
 434         {
 435 #if DEBUG_TESTING
 436           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 437                       "Starting `%s', with command `%s %s %s %s %s %s'.\n",
 438                       "gnunet-arm", "gnunet-arm", "-c", d->cfgfile,
 439                       "-L", "DEBUG",
 440                       "-s");
 441 #endif
 442           d->pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm",
 443                                             "gnunet-arm",
 444                                             "-c", d->cfgfile,
 445 #if DEBUG_TESTING
 446                                             "-L", "DEBUG",
 447 #endif
 448                                             "-s", "-q", 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_DEBUG,
 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->pid = GNUNET_OS_start_process (NULL, NULL, "ssh",
 466                                                 "ssh",
 467 #if !DEBUG_TESTING
 468                                                 "-q",
 469 #endif
 470                                                 dst,
 471                                                 "gnunet-arm",
 472 #if DEBUG_TESTING
 473                                                 "-L", "DEBUG",
 474 #endif
 475                                                 "-c", d->cfgfile, "-s", "-q", NULL);
 476             }
 477           else
 478             {
 479
 480               d->pid = GNUNET_OS_start_process (NULL, NULL, "ssh",
 481                                                 "ssh", "-p", d->ssh_port_str,
 482 #if !DEBUG_TESTING
 483                                                 "-q",
 484 #endif
 485                                                 dst,
 486                                                 "gnunet-arm",
 487 #if DEBUG_TESTING
 488                                                 "-L", "DEBUG",
 489 #endif
 490                                                 "-c", d->cfgfile, "-s", "-q", NULL);
 491             }
 492           GNUNET_free (dst);
 493         }
 494       if (-1 == d->pid)
 495         {
 496           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 497                       _("Could not start `%s' process to start GNUnet.\n"),
 498                       (NULL == d->hostname) ? "gnunet-arm" : "ssh");
 499           cb = d->cb;
 500           d->cb = NULL;
 501           if (NULL != cb)
 502             cb (d->cb_cls,
 503                 NULL,
 504                 d->cfg,
 505                 d,
 506                 (NULL == d->hostname)
 507                 ? _("Failed to start `gnunet-arm' process.\n")
 508                 : _("Failed to start `ssh' process.\n"));
 509           return;
 510         }
 511 #if DEBUG_TESTING
 512       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 513                   "Started `%s', waiting for `%s' to be up.\n",
 514                   "gnunet-arm", "gnunet-service-core");
 515 #endif
 516       d->phase = SP_START_ARMING;
 517       d->task
 518         = GNUNET_SCHEDULER_add_delayed (d->sched,
 519                                         GNUNET_CONSTANTS_EXEC_WAIT,
 520                                         &start_fsm, d);
 521       break;
 522     case SP_START_ARMING:
 523       if (GNUNET_OK != GNUNET_OS_process_status (d->pid, &type, &code))
 524         {
 525           if (GNUNET_TIME_absolute_get_remaining(d->max_timeout).value == 0)
 526             {
 527               cb = d->cb;
 528               d->cb = NULL;
 529               if (NULL != cb)
 530                 cb (d->cb_cls,
 531                     NULL,
 532                     d->cfg,
 533                     d,
 534                     (NULL == d->hostname)
 535                     ? _("`gnunet-arm' does not seem to terminate.\n")
 536                     : _("`ssh' does not seem to terminate.\n"));
 537               return;
 538             }
 539           /* wait some more */
 540           d->task
 541             = GNUNET_SCHEDULER_add_delayed (d->sched,
 542                                             GNUNET_CONSTANTS_EXEC_WAIT,
 543                                             &start_fsm, d);
 544           return;
 545         }
 546 #if DEBUG_TESTING
 547       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 548                   "Successfully started `%s'.\n", "gnunet-arm");
 549 #endif
 550       d->phase = SP_START_CORE;
 551       d->server = GNUNET_CORE_connect (d->sched,
 552                                        d->cfg,
 553                                        ARM_START_WAIT,
 554                                        d,
 555                                        &testing_init,
 556                                        NULL, NULL, NULL,
 557                                        NULL, GNUNET_NO,
 558                                        NULL, GNUNET_NO, no_handlers);
 559       break;
 560     case SP_START_CORE:
 561       GNUNET_break (0);
 562       break;
 563     case SP_START_DONE:
 564       GNUNET_break (0);
 565       break;
 566     case SP_SHUTDOWN_START:
 567       /* confirm copying complete */
 568       if (GNUNET_OK != GNUNET_OS_process_status (d->pid, &type, &code))
 569         {
 570           if (GNUNET_TIME_absolute_get_remaining(d->max_timeout).value == 0)
 571             {
 572               if (NULL != d->dead_cb)
 573                 d->dead_cb (d->dead_cb_cls,
 574                             _("either `gnunet-arm' or `ssh' does not seem to terminate.\n"));
 575               if (d->th != NULL)
 576                 {
 577                   GNUNET_TRANSPORT_get_hello_cancel(d->th, &process_hello, d);
 578                   GNUNET_TRANSPORT_disconnect(d->th);
 579                   d->th = NULL;
 580                 }
 581               GNUNET_CONFIGURATION_destroy (d->cfg);
 582               GNUNET_free (d->cfgfile);
 583               GNUNET_free_non_null(d->hello);
 584               GNUNET_free_non_null (d->hostname);
 585               GNUNET_free_non_null (d->username);
 586               GNUNET_free_non_null (d->shortname);
 587               GNUNET_free (d);
 588               return;
 589             }
 590           /* wait some more */
 591           d->task
 592             = GNUNET_SCHEDULER_add_delayed (d->sched,
 593                                             GNUNET_CONSTANTS_EXEC_WAIT,
 594                                             &start_fsm, d);
 595           return;
 596         }
 597       if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 598         {
 599           if (NULL != d->dead_cb)
 600             d->dead_cb (d->dead_cb_cls,
 601                         _("shutdown (either `gnunet-arm' or `ssh') did not complete cleanly.\n"));
 602           if (d->th != NULL)
 603             {
 604               GNUNET_TRANSPORT_get_hello_cancel(d->th, &process_hello, d);
 605               GNUNET_TRANSPORT_disconnect(d->th);
 606               d->th = NULL;
 607             }
 608           GNUNET_CONFIGURATION_destroy (d->cfg);
 609           GNUNET_free (d->cfgfile);
 610           GNUNET_free_non_null(d->hello);
 611           GNUNET_free_non_null (d->hostname);
 612           GNUNET_free_non_null (d->username);
 613           GNUNET_free_non_null (d->shortname);
 614           GNUNET_free (d);
 615           return;
 616         }
 617 #if DEBUG_TESTING
 618       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer shutdown complete.\n");
 619 #endif
 620       if (d->th != NULL)
 621         {
 622           GNUNET_TRANSPORT_get_hello_cancel(d->th, &process_hello, d);
 623           GNUNET_TRANSPORT_disconnect(d->th);
 624           d->th = NULL;
 625         }
 626       /* state clean up and notifications */
 627       if (d->churn == GNUNET_NO)
 628         {
 629           GNUNET_CONFIGURATION_destroy (d->cfg);
 630           GNUNET_free (d->cfgfile);
 631           GNUNET_free_non_null (d->hostname);
 632           GNUNET_free_non_null (d->username);
 633         }
 634
 635       GNUNET_free_non_null(d->hello);
 636       d->hello = NULL;
 637       GNUNET_free_non_null (d->shortname);
 638       d->shortname = NULL;
 639       if (NULL != d->dead_cb)
 640         d->dead_cb (d->dead_cb_cls, NULL);
 641
 642       if (d->churn == GNUNET_NO)
 643         GNUNET_free (d);
 644
 645       break;
 646     case SP_CONFIG_UPDATE:
 647       /* confirm copying complete */
 648       if (GNUNET_OK != GNUNET_OS_process_status (d->pid, &type, &code))
 649         {
 650           if (GNUNET_TIME_absolute_get_remaining(d->max_timeout).value == 0) /* FIXME: config update should take timeout parameter! */
 651             {
 652               cb = d->cb;
 653               d->cb = NULL;
 654               if (NULL != cb)
 655                 cb (d->cb_cls,
 656                     NULL,
 657                     d->cfg, d, _("`scp' does not seem to terminate.\n"));
 658               return;
 659             }
 660           /* wait some more */
 661           d->task
 662             = GNUNET_SCHEDULER_add_delayed (d->sched,
 663                                             GNUNET_CONSTANTS_EXEC_WAIT,
 664                                             &start_fsm, d);
 665           return;
 666         }
 667       if ((type != GNUNET_OS_PROCESS_EXITED) || (code != 0))
 668         {
 669           if (NULL != d->update_cb)
 670             d->update_cb (d->update_cb_cls,
 671                           _("`scp' did not complete cleanly.\n"));
 672           return;
 673         }
 674 #if DEBUG_TESTING
 675       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 676                   "Successfully copied configuration file.\n");
 677 #endif
 678       if (NULL != d->update_cb)
 679         d->update_cb (d->update_cb_cls, NULL);
 680       d->phase = SP_START_DONE;
 681       break;
 682     }
 683 }
 684
 685 /**
 686  * Continues GNUnet daemon startup when user wanted to be notified
 687  * once a hostkey was generated (for creating friends files, blacklists,
 688  * etc.).
 689  *
 690  * @param daemon the daemon to finish starting
 691  */
 692 void
 693 GNUNET_TESTING_daemon_continue_startup(struct GNUNET_TESTING_Daemon *daemon)
 694 {
 695   GNUNET_assert(daemon->phase == SP_HOSTKEY_CREATED);
 696   daemon->phase = SP_TOPOLOGY_SETUP;
 697 }
 698
 699 /**
 700  * Check whether the given daemon is running.
 701  *
 702  * @param daemon the daemon to check
 703  *
 704  * @return GNUNET_YES if the daemon is up, GNUNET_NO if the
 705  *         daemon is down, GNUNET_SYSERR on error.
 706  */
 707 int
 708 GNUNET_TESTING_daemon_running (struct GNUNET_TESTING_Daemon *daemon)
 709 {
 710   if (daemon == NULL)
 711     return GNUNET_SYSERR;
 712
 713   if (daemon->running == GNUNET_YES)
 714     return GNUNET_YES;
 715   return GNUNET_NO;
 716 }
 717
 718
 719 /**
 720  * Start a peer that has previously been stopped using the daemon_stop
 721  * call (and files weren't deleted and the allow restart flag)
 722  *
 723  * @param daemon the daemon to start (has been previously stopped)
 724  * @param timeout how long to wait for restart
 725  * @param cb the callback for notification when the peer is running
 726  * @param cb_cls closure for the callback
 727  */
 728 void
 729 GNUNET_TESTING_daemon_start_stopped (struct GNUNET_TESTING_Daemon *daemon,
 730                                      struct GNUNET_TIME_Relative timeout,
 731                                      GNUNET_TESTING_NotifyDaemonRunning cb,
 732                                      void *cb_cls)
 733 {
 734   if (daemon->running == GNUNET_YES)
 735   {
 736     cb(cb_cls, &daemon->id, daemon->cfg, daemon, "Daemon already running, can't restart!");
 737     return;
 738   }
 739
 740   daemon->cb = cb;
 741   daemon->cb_cls = cb_cls;
 742   daemon->phase = SP_TOPOLOGY_SETUP;
 743   daemon->max_timeout = GNUNET_TIME_relative_to_absolute(timeout);
 744
 745   GNUNET_SCHEDULER_add_continuation (daemon->sched,
 746                                      &start_fsm,
 747                                      daemon,
 748                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 749 }
 750
 751 /**
 752  * Starts a GNUnet daemon.  GNUnet must be installed on the target
 753  * system and available in the PATH.  The machine must furthermore be
 754  * reachable via "ssh" (unless the hostname is "NULL") without the
 755  * need to enter a password.
 756  *
 757  * @param sched scheduler to use
 758  * @param cfg configuration to use
 759  * @param timeout how long to wait starting up peers
 760  * @param hostname name of the machine where to run GNUnet
 761  *        (use NULL for localhost).
 762  * @param ssh_username ssh username to use when connecting to hostname
 763  * @param sshport port to pass to ssh process when connecting to hostname
 764  * @param hostkey_callback function to call once the hostkey has been
 765  *        generated for this peer, but it hasn't yet been started
 766  *        (NULL to start immediately, otherwise waits on GNUNET_TESTING_daemon_continue_start)
 767  * @param hostkey_cls closure for hostkey callback
 768  * @param cb function to call once peer is up, or failed to start
 769  * @param cb_cls closure for cb
 770  * @return handle to the daemon (actual start will be completed asynchronously)
 771  */
 772 struct GNUNET_TESTING_Daemon *
 773 GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched,
 774                              const struct GNUNET_CONFIGURATION_Handle *cfg,
 775                              struct GNUNET_TIME_Relative timeout,
 776                              const char *hostname,
 777                              const char *ssh_username,
 778                              uint16_t sshport,
 779                              GNUNET_TESTING_NotifyHostkeyCreated hostkey_callback,
 780                              void *hostkey_cls,
 781                              GNUNET_TESTING_NotifyDaemonRunning cb,
 782                              void *cb_cls)
 783 {
 784   struct GNUNET_TESTING_Daemon *ret;
 785   char *arg;
 786   char *username;
 787
 788   ret = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Daemon));
 789   ret->sched = sched;
 790   ret->hostname = (hostname == NULL) ? NULL : GNUNET_strdup (hostname);
 791   if (sshport != 0)
 792     {
 793       GNUNET_asprintf(&ret->ssh_port_str, "%d", sshport);
 794     }
 795   else
 796     ret->ssh_port_str = NULL;
 797   ret->cfgfile = GNUNET_DISK_mktemp ("gnunet-testing-config");
 798 #if DEBUG_TESTING
 799   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 800               "Setting up peer with configuration file `%s'.\n",
 801               ret->cfgfile);
 802 #endif
 803   if (NULL == ret->cfgfile)
 804     {
 805       GNUNET_free_non_null (ret->hostname);
 806       GNUNET_free (ret);
 807       return NULL;
 808     }
 809   ret->hostkey_callback = hostkey_callback;
 810   ret->hostkey_cls = hostkey_cls;
 811   ret->cb = cb;
 812   ret->cb_cls = cb_cls;
 813   ret->max_timeout = GNUNET_TIME_relative_to_absolute(timeout);
 814   ret->cfg = GNUNET_CONFIGURATION_dup (cfg);
 815   GNUNET_CONFIGURATION_set_value_string (ret->cfg,
 816                                          "PATHS",
 817                                          "DEFAULTCONFIG", ret->cfgfile);
 818   /* 1) write configuration to temporary file */
 819   if (GNUNET_OK != GNUNET_CONFIGURATION_write (ret->cfg, ret->cfgfile))
 820     {
 821       if (0 != UNLINK (ret->cfgfile))
 822         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
 823                                   "unlink", ret->cfgfile);
 824       GNUNET_CONFIGURATION_destroy (ret->cfg);
 825       GNUNET_free_non_null (ret->hostname);
 826       GNUNET_free (ret->cfgfile);
 827       GNUNET_free (ret);
 828       return NULL;
 829     }
 830   if (ssh_username != NULL)
 831     username = GNUNET_strdup(ssh_username);
 832   if ((ssh_username == NULL) && (GNUNET_OK !=
 833       GNUNET_CONFIGURATION_get_value_string (cfg,
 834                                              "TESTING",
 835                                              "USERNAME", &username)))
 836     {
 837       if (NULL != getenv ("USER"))
 838         username = GNUNET_strdup (getenv ("USER"));
 839       else
 840         username = NULL;
 841     }
 842   ret->username = username;
 843
 844   /* 2) copy file to remote host */
 845   if (NULL != hostname)
 846     {
 847 #if DEBUG_TESTING
 848       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 849                   "Copying configuration file to host `%s'.\n", hostname);
 850 #endif
 851       ret->phase = SP_COPYING;
 852       if (NULL != username)
 853         GNUNET_asprintf (&arg, "%s@%s:%s", username, hostname, ret->cfgfile);
 854       else
 855         GNUNET_asprintf (&arg, "%s:%s", hostname, ret->cfgfile);
 856
 857       if (ret->ssh_port_str == NULL)
 858         {
 859           ret->pid = GNUNET_OS_start_process (NULL, NULL, "scp",
 860                                               "scp",
 861 #if !DEBUG_TESTING
 862                                               "-q",
 863 #endif
 864                                               ret->cfgfile, arg, NULL);
 865         }
 866       else
 867         {
 868           ret->pid = GNUNET_OS_start_process (NULL, NULL, "scp",
 869                                               "scp", "-P", ret->ssh_port_str,
 870 #if !DEBUG_TESTING
 871                                               "-q",
 872 #endif
 873                                               ret->cfgfile, arg, NULL);
 874         }
 875       GNUNET_free (arg);
 876       if (-1 == ret->pid)
 877         {
 878           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 879                       _
 880                       ("Could not start `%s' process to copy configuration file.\n"),
 881                       "scp");
 882           if (0 != UNLINK (ret->cfgfile))
 883             GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
 884                                       "unlink", ret->cfgfile);
 885           GNUNET_CONFIGURATION_destroy (ret->cfg);
 886           GNUNET_free_non_null (ret->hostname);
 887           GNUNET_free_non_null (ret->username);
 888           GNUNET_free (ret->cfgfile);
 889           GNUNET_free (ret);
 890           return NULL;
 891         }
 892       ret->task
 893         = GNUNET_SCHEDULER_add_delayed (sched,
 894                                         GNUNET_CONSTANTS_EXEC_WAIT,
 895                                         &start_fsm, ret);
 896       return ret;
 897     }
 898 #if DEBUG_TESTING
 899   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 900               "No need to copy configuration file since we are running locally.\n");
 901 #endif
 902   ret->phase = SP_COPIED;
 903   GNUNET_SCHEDULER_add_continuation (sched,
 904                                      &start_fsm,
 905                                      ret,
 906                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 907   return ret;
 908 }
 909
 910
 911 /**
 912  * Restart (stop and start) a GNUnet daemon.
 913  *
 914  * @param d the daemon that should be restarted
 915  * @param cb function called once the daemon is (re)started
 916  * @param cb_cls closure for cb
 917  */
 918 void
 919 GNUNET_TESTING_daemon_restart (struct GNUNET_TESTING_Daemon *d,
 920                                GNUNET_TESTING_NotifyDaemonRunning cb, void *cb_cls)
 921 {
 922   char *arg;
 923   char *del_arg;
 924
 925   del_arg = NULL;
 926   if (NULL != d->cb)
 927     {
 928       d->dead = GNUNET_YES;
 929       return;
 930     }
 931
 932   d->cb = cb;
 933   d->cb_cls = cb_cls;
 934
 935   if (d->phase == SP_CONFIG_UPDATE)
 936     {
 937       GNUNET_SCHEDULER_cancel (d->sched, d->task);
 938       d->phase = SP_START_DONE;
 939     }
 940   if (d->server != NULL)
 941     {
 942       GNUNET_CORE_disconnect (d->server);
 943       d->server = NULL;
 944     }
 945
 946   if (d->th != NULL)
 947     {
 948       GNUNET_TRANSPORT_get_hello_cancel(d->th, &process_hello, d);
 949       GNUNET_TRANSPORT_disconnect(d->th);
 950       d->th = NULL;
 951     }
 952   /* state clean up and notifications */
 953   GNUNET_free_non_null(d->hello);
 954
 955 #if DEBUG_TESTING
 956     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 957                 _("Terminating peer `%4s'\n"), GNUNET_i2s (&d->id));
 958 #endif
 959
 960    d->phase = SP_START_ARMING;
 961
 962     /* Check if this is a local or remote process */
 963   if (NULL != d->hostname)
 964     {
 965 #if DEBUG_TESTING
 966       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 967                   "Stopping gnunet-arm with config `%s' on host `%s'.\n", d->cfgfile, d->hostname);
 968 #endif
 969
 970       if (d->username != NULL)
 971         GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
 972       else
 973         arg = GNUNET_strdup (d->hostname);
 974
 975       d->pid = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
 976 #if !DEBUG_TESTING
 977                                         "-q",
 978 #endif
 979                                         arg, "gnunet-arm",
 980 #if DEBUG_TESTING
 981                                         "-L", "DEBUG",
 982 #endif
 983                                         "-c", d->cfgfile, "-e", "-r", NULL);
 984       /* Use -r to restart arm and all services */
 985
 986       GNUNET_free (arg);
 987     }
 988   else
 989     {
 990 #if DEBUG_TESTING
 991       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 992                   "Stopping gnunet-arm with config `%s' locally.\n", d->cfgfile);
 993 #endif
 994       d->pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm",
 995                                         "gnunet-arm",
 996 #if DEBUG_TESTING
 997                                         "-L", "DEBUG",
 998 #endif
 999                                         "-c", d->cfgfile, "-e", "-r", NULL);
1000     }
1001
1002     GNUNET_free_non_null(del_arg);
1003     d->task
1004       = GNUNET_SCHEDULER_add_delayed (d->sched,
1005                                       GNUNET_CONSTANTS_EXEC_WAIT,
1006                                       &start_fsm, d);
1007
1008 }
1009
1010
1011 /**
1012  * Stops a GNUnet daemon.
1013  *
1014  * @param d the daemon that should be stopped
1015  * @param timeout how long to wait for process for shutdown to complete
1016  * @param cb function called once the daemon was stopped
1017  * @param cb_cls closure for cb
1018  * @param delete_files GNUNET_YES to remove files, GNUNET_NO
1019  *        to leave them
1020  * @param allow_restart GNUNET_YES to restart peer later (using this API)
1021  *        GNUNET_NO to kill off and clean up for good
1022  */
1023 void
1024 GNUNET_TESTING_daemon_stop (struct GNUNET_TESTING_Daemon *d,
1025                             struct GNUNET_TIME_Relative timeout,
1026                             GNUNET_TESTING_NotifyCompletion cb, void *cb_cls,
1027                             int delete_files,
1028                             int allow_restart)
1029 {
1030   char *arg;
1031   char *del_arg;
1032   d->dead_cb = cb;
1033   d->dead_cb_cls = cb_cls;
1034
1035   if (NULL != d->cb)
1036     {
1037 #if DEBUG_TESTING
1038       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1039                  _("Setting d->dead on peer `%4s'\n"), GNUNET_i2s (&d->id));
1040 #endif
1041       d->dead = GNUNET_YES;
1042       return;
1043     }
1044
1045   if ((d->running == GNUNET_NO) && (d->churn == GNUNET_YES)) /* Peer has already been stopped in churn context! */
1046     {
1047       /* Free what was left from churning! */
1048       GNUNET_assert(d->cfg != NULL);
1049       GNUNET_CONFIGURATION_destroy (d->cfg);
1050       if (delete_files == GNUNET_YES)
1051         {
1052           if (0 != UNLINK(d->cfgfile))
1053             {
1054               GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "unlink");
1055             }
1056         }
1057       GNUNET_free (d->cfgfile);
1058       GNUNET_free_non_null (d->hostname);
1059       GNUNET_free_non_null (d->username);
1060       if (NULL != d->dead_cb)
1061         d->dead_cb (d->dead_cb_cls, NULL);
1062       GNUNET_free(d);
1063       return;
1064     }
1065
1066   del_arg = NULL;
1067   if (delete_files == GNUNET_YES)
1068     {
1069       GNUNET_asprintf(&del_arg, "-d");
1070     }
1071
1072   if (d->phase == SP_CONFIG_UPDATE)
1073     {
1074       GNUNET_SCHEDULER_cancel (d->sched, d->task);
1075       d->phase = SP_START_DONE;
1076     }
1077   if (d->server != NULL)
1078     {
1079       GNUNET_CORE_disconnect (d->server);
1080       d->server = NULL;
1081     }
1082   /* shutdown ARM process (will terminate others) */
1083 #if DEBUG_TESTING
1084   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1085               _("Terminating peer `%4s'\n"), GNUNET_i2s (&d->id));
1086 #endif
1087   d->phase = SP_SHUTDOWN_START;
1088   d->running = GNUNET_NO;
1089   if (allow_restart == GNUNET_YES)
1090     d->churn = GNUNET_YES;
1091   if (d->th != NULL)
1092     {
1093       GNUNET_TRANSPORT_get_hello_cancel(d->th, &process_hello, d);
1094       GNUNET_TRANSPORT_disconnect(d->th);
1095       d->th = NULL;
1096     }
1097   /* Check if this is a local or remote process */
1098   if (NULL != d->hostname)
1099     {
1100 #if DEBUG_TESTING
1101       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1102                   "Stopping gnunet-arm with config `%s' on host `%s'.\n", d->cfgfile, d->hostname);
1103 #endif
1104
1105       if (d->username != NULL)
1106         GNUNET_asprintf (&arg, "%s@%s", d->username, d->hostname);
1107       else
1108         arg = GNUNET_strdup (d->hostname);
1109
1110       d->pid = GNUNET_OS_start_process (NULL, NULL, "ssh", "ssh",
1111 #if !DEBUG_TESTING
1112                                         "-q",
1113 #endif
1114                                         arg, "gnunet-arm",
1115 #if DEBUG_TESTING
1116                                         "-L", "DEBUG",
1117 #endif
1118                                         "-c", d->cfgfile, "-e", "-q", del_arg, NULL);
1119       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1120                   "Stopping gnunet-arm with command ssh %s gnunet-arm -c %s -e -q %s\n", arg, "gnunet-arm", d->cfgfile, del_arg);
1121       /* Use -e to end arm, and -d to remove temp files */
1122       GNUNET_free (arg);
1123     }
1124   else
1125     {
1126 #if DEBUG_TESTING
1127       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1128                   "Stopping gnunet-arm with config `%s' locally.\n", d->cfgfile);
1129 #endif
1130       d->pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-arm",
1131                                         "gnunet-arm",
1132 #if DEBUG_TESTING
1133                                         "-L", "DEBUG",
1134 #endif
1135                                         "-c", d->cfgfile, "-e", "-q", del_arg, NULL);
1136     }
1137
1138   GNUNET_free_non_null(del_arg);
1139   d->max_timeout = GNUNET_TIME_relative_to_absolute(timeout);
1140   d->task
1141     = GNUNET_SCHEDULER_add_now (d->sched,
1142                                 &start_fsm, d);
1143 }
1144
1145
1146 /**
1147  * Changes the configuration of a GNUnet daemon.
1148  *
1149  * @param d the daemon that should be modified
1150  * @param cfg the new configuration for the daemon
1151  * @param cb function called once the configuration was changed
1152  * @param cb_cls closure for cb
1153  */
1154 void
1155 GNUNET_TESTING_daemon_reconfigure (struct GNUNET_TESTING_Daemon *d,
1156                                    struct GNUNET_CONFIGURATION_Handle *cfg,
1157                                    GNUNET_TESTING_NotifyCompletion cb,
1158                                    void *cb_cls)
1159 {
1160   char *arg;
1161
1162   if (d->phase != SP_START_DONE)
1163     {
1164       if (NULL != cb)
1165         cb (cb_cls,
1166             _
1167             ("Peer not yet running, can not change configuration at this point."));
1168       return;
1169     }
1170
1171   /* 1) write configuration to temporary file */
1172   if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, d->cfgfile))
1173     {
1174       if (NULL != cb)
1175         cb (cb_cls, _("Failed to write new configuration to disk."));
1176       return;
1177     }
1178
1179   /* 2) copy file to remote host (if necessary) */
1180   if (NULL == d->hostname)
1181     {
1182       /* signal success */
1183       if (NULL != cb)
1184         cb (cb_cls, NULL);
1185       return;
1186     }
1187 #if DEBUG_TESTING
1188   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1189               "Copying updated configuration file to remote host `%s'.\n",
1190               d->hostname);
1191 #endif
1192   d->phase = SP_CONFIG_UPDATE;
1193   if (NULL != d->username)
1194     GNUNET_asprintf (&arg, "%s@%s:%s", d->username, d->hostname, d->cfgfile);
1195   else
1196     GNUNET_asprintf (&arg, "%s:%s", d->hostname, d->cfgfile);
1197   d->pid = GNUNET_OS_start_process (NULL, NULL, "scp", "scp",
1198 #if !DEBUG_TESTING
1199                                     "-q",
1200 #endif
1201                                     d->cfgfile, arg, NULL);
1202   GNUNET_free (arg);
1203   if (-1 == d->pid)
1204     {
1205       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1206                   _
1207                   ("Could not start `%s' process to copy configuration file.\n"),
1208                   "scp");
1209       if (NULL != cb)
1210         cb (cb_cls, _("Failed to copy new configuration to remote machine."));
1211       d->phase = SP_START_DONE;
1212       return;
1213     }
1214   d->update_cb = cb;
1215   d->update_cb_cls = cb_cls;
1216   d->task
1217     = GNUNET_SCHEDULER_add_delayed (d->sched,
1218                                     GNUNET_CONSTANTS_EXEC_WAIT,
1219                                     &start_fsm, d);
1220 }
1221
1222
1223 /**
1224  * Data kept for each pair of peers that we try
1225  * to connect.
1226  */
1227 struct ConnectContext
1228 {
1229   /**
1230    * Testing handle to the first daemon.
1231    */
1232   struct GNUNET_TESTING_Daemon *d1;
1233
1234   /**
1235    * Handle to core of first daemon (to check connect)
1236    */
1237   struct GNUNET_CORE_Handle * d1core;
1238
1239   /**
1240    * Testing handle to the second daemon.
1241    */
1242   struct GNUNET_TESTING_Daemon *d2;
1243
1244   /**
1245    * Handler for the request to core to connect to this peer.
1246    */
1247   struct GNUNET_CORE_PeerRequestHandle *connect_request_handle;
1248
1249   /**
1250    * Transport handle to the second daemon.
1251    */
1252   struct GNUNET_TRANSPORT_Handle *d2th;
1253
1254   /**
1255    * Function to call once we are done (or have timed out).
1256    */
1257   GNUNET_TESTING_NotifyConnection cb;
1258
1259   /**
1260    * Closure for "nb".
1261    */
1262   void *cb_cls;
1263
1264   /**
1265    * When should this operation be complete (or we must trigger
1266    * a timeout).
1267    */
1268   struct GNUNET_TIME_Absolute timeout;
1269
1270   /**
1271    * The relative timeout from whence this connect attempt was
1272    * started.  Allows for reconnect attempts.
1273    */
1274   struct GNUNET_TIME_Relative relative_timeout;
1275
1276   /**
1277    * Maximum number of connect attempts, will retry connection
1278    * this number of times on failures.
1279    */
1280   unsigned int max_connect_attempts;
1281
1282   /**
1283    * Hello timeout task
1284    */
1285   GNUNET_SCHEDULER_TaskIdentifier hello_send_task;
1286
1287   /**
1288    * Connect timeout task
1289    */
1290   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
1291
1292   /**
1293    * When should this operation be complete (or we must trigger
1294    * a timeout).
1295    */
1296   struct GNUNET_TIME_Relative timeout_hello;
1297
1298   /**
1299    * Was the connection attempt successful?
1300    */
1301   int connected;
1302
1303   /**
1304    * The distance between the two connected peers
1305    */
1306   uint32_t distance;
1307 };
1308
1309
1310 /** Forward declaration **/
1311 static void
1312 reattempt_daemons_connect(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
1313
1314
1315 /**
1316  * Notify callback about success or failure of the attempt
1317  * to connect the two peers
1318  *
1319  * @param cls our "struct ConnectContext" (freed)
1320  * @param tc reason tells us if we succeeded or failed
1321  */
1322 static void
1323 notify_connect_result (void *cls,
1324                        const struct GNUNET_SCHEDULER_TaskContext *tc)
1325 {
1326   struct ConnectContext *ctx = cls;
1327   struct GNUNET_TIME_Relative remaining;
1328
1329   ctx->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1330   if (ctx->hello_send_task != GNUNET_SCHEDULER_NO_TASK)
1331     {
1332       GNUNET_SCHEDULER_cancel(ctx->d1->sched, ctx->hello_send_task);
1333       ctx->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
1334     }
1335
1336   if (ctx->connect_request_handle != NULL)
1337     {
1338       GNUNET_CORE_peer_request_connect_cancel (ctx->connect_request_handle);
1339       ctx->connect_request_handle = NULL;
1340     }
1341   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
1342     {
1343       if (ctx->d2th != NULL)
1344         GNUNET_TRANSPORT_disconnect (ctx->d2th);
1345       ctx->d2th = NULL;
1346       if (ctx->d1core != NULL)
1347         GNUNET_CORE_disconnect (ctx->d1core);
1348 #if CONNECT_CORE2
1349       if (ctx->d2core != NULL)
1350         GNUNET_CORE_disconnect (ctx->d2core);
1351       ctx->d2core = NULL;
1352 #endif
1353       ctx->d1core = NULL;
1354
1355       GNUNET_free (ctx);
1356       return;
1357     }
1358
1359   remaining = GNUNET_TIME_absolute_get_remaining(ctx->timeout);
1360
1361   if (ctx->connected == GNUNET_YES)
1362     {
1363       if (ctx->cb != NULL)
1364         {
1365           ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, ctx->distance, ctx->d1->cfg,
1366                    ctx->d2->cfg, ctx->d1, ctx->d2, NULL);
1367         }
1368     }
1369   else if (remaining.value > 0)
1370     {
1371       if (ctx->d1core != NULL)
1372         {
1373           GNUNET_CORE_disconnect(ctx->d1core);
1374           ctx->d1core = NULL;
1375         }
1376 #if CONNECT_CORE2
1377       if (ctx->d2core != NULL)
1378         {
1379           GNUNET_CORE_disconnect(ctx->d2core);
1380           ctx->d2core = NULL;
1381         }
1382 #endif
1383
1384       if (ctx->d2th != NULL)
1385         {
1386           GNUNET_TRANSPORT_disconnect(ctx->d2th);
1387           ctx->d2th = NULL;
1388         }
1389       GNUNET_SCHEDULER_add_now(ctx->d1->sched, &reattempt_daemons_connect, ctx);
1390       return;
1391     }
1392   else
1393     {
1394       if (ctx->cb != NULL)
1395         {
1396           ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg,
1397                    ctx->d2->cfg, ctx->d1, ctx->d2,
1398                    _("Peers failed to connect"));
1399         }
1400     }
1401
1402   GNUNET_TRANSPORT_disconnect (ctx->d2th);
1403   ctx->d2th = NULL;
1404   GNUNET_CORE_disconnect (ctx->d1core);
1405   ctx->d1core = NULL;
1406   GNUNET_free (ctx);
1407 }
1408
1409
1410 /**
1411  * Success, connection is up.  Signal client our success.
1412  *
1413  * @param cls our "struct ConnectContext"
1414  * @param peer identity of the peer that has connected
1415  * @param latency the round trip latency of the connection to this peer
1416  * @param distance distance the transport level distance to this peer
1417  *
1418  */
1419 static void
1420 connect_notify (void *cls, const struct GNUNET_PeerIdentity * peer, struct GNUNET_TIME_Relative latency,
1421                 uint32_t distance)
1422 {
1423   struct ConnectContext *ctx = cls;
1424
1425   if (memcmp(&ctx->d2->id, peer, sizeof(struct GNUNET_PeerIdentity)) == 0)
1426     {
1427       ctx->connected = GNUNET_YES;
1428       ctx->distance = distance;
1429       GNUNET_SCHEDULER_cancel(ctx->d1->sched, ctx->timeout_task);
1430       ctx->timeout_task = GNUNET_SCHEDULER_add_now (ctx->d1->sched,
1431                                                     &notify_connect_result,
1432                                                     ctx);
1433     }
1434
1435 }
1436
1437 #if CONNECT_CORE2
1438 /**
1439  * Success, connection is up.  Signal client our success.
1440  *
1441  * @param cls our "struct ConnectContext"
1442  * @param peer identity of the peer that has connected
1443  * @param latency the round trip latency of the connection to this peer
1444  * @param distance distance the transport level distance to this peer
1445  *
1446  */
1447 static void
1448 connect_notify_core2 (void *cls, const struct GNUNET_PeerIdentity * peer, struct GNUNET_TIME_Relative latency,
1449                 uint32_t distance)
1450 {
1451   struct ConnectContext *ctx = cls;
1452
1453   if (memcmp(&ctx->d2->id, peer, sizeof(struct GNUNET_PeerIdentity)) == 0)
1454     {
1455       ctx->connected = GNUNET_YES;
1456       ctx->distance = distance;
1457       GNUNET_SCHEDULER_cancel(ctx->d1->sched, ctx->timeout_task);
1458       ctx->timeout_task = GNUNET_SCHEDULER_add_now (ctx->d1->sched,
1459                                                     &notify_connect_result,
1460                                                     ctx);
1461     }
1462
1463 }
1464 #endif
1465
1466 /**
1467  * Task called once a core connect request has been transmitted.
1468  *
1469  * @param cls struct ConnectContext
1470  * @param tc context information (why was this task triggered now)
1471  */
1472 void core_connect_request_cont (void *cls,
1473                                 const struct
1474                                 GNUNET_SCHEDULER_TaskContext * tc)
1475 {
1476   struct ConnectContext *ctx = cls;
1477
1478   if (tc->reason == GNUNET_SCHEDULER_REASON_PREREQ_DONE)
1479     ctx->connect_request_handle = NULL;
1480   return;
1481 }
1482
1483 static void
1484 send_hello(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1485 {
1486   struct ConnectContext *ctx = cls;
1487   struct GNUNET_MessageHeader *hello;
1488   ctx->hello_send_task = GNUNET_SCHEDULER_NO_TASK;
1489   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
1490     return;
1491   if ((ctx->d1->hello != NULL) && (NULL != GNUNET_HELLO_get_header(ctx->d1->hello)))
1492     {
1493       hello = GNUNET_HELLO_get_header(ctx->d1->hello);
1494       GNUNET_assert(hello != NULL);
1495       GNUNET_TRANSPORT_offer_hello (ctx->d2th, hello);
1496
1497       ctx->connect_request_handle = GNUNET_CORE_peer_request_connect (ctx->d1->sched,
1498                                                                       ctx->d2->cfg,
1499                                                                       GNUNET_TIME_relative_divide(ctx->relative_timeout,
1500                                                                                                   ctx->max_connect_attempts + 1),
1501                                                                       &ctx->d1->id,
1502                                                                       &core_connect_request_cont,
1503                                                                       ctx);
1504       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending connect request to core for peer %s\n", GNUNET_i2s(&ctx->d1->id));
1505       ctx->timeout_hello = GNUNET_TIME_relative_add(ctx->timeout_hello,
1506                                                     GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
1507                                                                                   500));
1508     }
1509   ctx->hello_send_task = GNUNET_SCHEDULER_add_delayed(ctx->d1->sched,
1510                                                       ctx->timeout_hello,
1511                                                       &send_hello, ctx);
1512 }
1513
1514 /**
1515  * Establish a connection between two GNUnet daemons.
1516  *
1517  * @param d1 handle for the first daemon
1518  * @param d2 handle for the second daemon
1519  * @param timeout how long is the connection attempt
1520  *        allowed to take?
1521  * @param max_connect_attempts how many times should we try to reconnect
1522  *        (within timeout)
1523  * @param cb function to call at the end
1524  * @param cb_cls closure for cb
1525  */
1526 void
1527 GNUNET_TESTING_daemons_connect (struct GNUNET_TESTING_Daemon *d1,
1528                                 struct GNUNET_TESTING_Daemon *d2,
1529                                 struct GNUNET_TIME_Relative timeout,
1530                                 unsigned int max_connect_attempts,
1531                                 GNUNET_TESTING_NotifyConnection cb,
1532                                 void *cb_cls)
1533 {
1534   struct ConnectContext *ctx;
1535
1536   if ((d1->running == GNUNET_NO) || (d2->running == GNUNET_NO))
1537     {
1538       if (NULL != cb)
1539         cb (cb_cls, &d1->id, &d2->id, 0, d1->cfg, d2->cfg, d1, d2,
1540             _("Peers are not fully running yet, can not connect!\n"));
1541       return;
1542     }
1543   ctx = GNUNET_malloc (sizeof (struct ConnectContext));
1544   ctx->d1 = d1;
1545   ctx->d2 = d2;
1546   ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1547   ctx->timeout_hello = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500);
1548   ctx->relative_timeout = timeout;
1549   ctx->cb = cb;
1550   ctx->cb_cls = cb_cls;
1551   ctx->max_connect_attempts = max_connect_attempts;
1552   ctx->connected = GNUNET_NO;
1553 #if DEBUG_TESTING
1554   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1555               "Asked to connect peer %s to peer %s\n",
1556               d1->shortname, d2->shortname);
1557 #endif
1558
1559   ctx->d1core = GNUNET_CORE_connect (d1->sched,
1560                                      d1->cfg,
1561                                      timeout,
1562                                      ctx,
1563                                      NULL,
1564                                      &connect_notify, NULL, NULL,
1565                                      NULL, GNUNET_NO,
1566                                      NULL, GNUNET_NO, no_handlers);
1567   if (ctx->d1core == NULL)
1568     {
1569       GNUNET_free (ctx);
1570       if (NULL != cb)
1571         cb (cb_cls, &d1->id, &d2->id, 0, d1->cfg, d2->cfg, d1, d2,
1572             _("Failed to connect to core service of first peer!\n"));
1573       return;
1574     }
1575
1576 #if CONNECT_CORE2
1577   ctx->d2core = GNUNET_CORE_connect (d2->sched,
1578                                      d2->cfg,
1579                                      timeout,
1580                                      ctx,
1581                                      NULL,
1582                                      NULL, NULL, NULL,
1583                                      NULL, GNUNET_NO,
1584                                      NULL, GNUNET_NO, no_handlers);
1585   if (ctx->d2core == NULL)
1586     {
1587       GNUNET_free (ctx);
1588       if (NULL != cb)
1589         cb (cb_cls, &d1->id, &d2->id, 0, d1->cfg, d2->cfg, d1, d2,
1590             _("Failed to connect to core service of second peer!\n"));
1591       return;
1592     }
1593 #endif
1594
1595 #if DEBUG_TESTING > 2
1596   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1597               "Asked to connect peer %s to peer %s\n",
1598               d1->shortname, d2->shortname);
1599   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1600               "Connecting to transport service of peer %s\n", d2->shortname);
1601
1602 #endif
1603
1604   ctx->d2th = GNUNET_TRANSPORT_connect (d2->sched,
1605                                         d2->cfg,
1606                                         &d2->id,
1607                                         d2, NULL, NULL, NULL);
1608   if (ctx->d2th == NULL)
1609     {
1610       GNUNET_CORE_disconnect(ctx->d1core);
1611       GNUNET_free (ctx);
1612       if (NULL != cb)
1613         cb (cb_cls, &d1->id, &d2->id, 0, d1->cfg, d2->cfg, d1, d2,
1614             _("Failed to connect to transport service!\n"));
1615       return;
1616     }
1617
1618   ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (d1->sched,
1619                                                     GNUNET_TIME_relative_divide(ctx->relative_timeout,
1620                                                     ctx->max_connect_attempts),
1621                                                     &notify_connect_result, ctx);
1622
1623   ctx->hello_send_task = GNUNET_SCHEDULER_add_now(ctx->d1->sched, &send_hello, ctx);
1624 }
1625
1626 static void
1627 reattempt_daemons_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1628 {
1629
1630   struct ConnectContext *ctx = cls;
1631   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
1632     {
1633       return;
1634     }
1635 #if DEBUG_TESTING_RECONNECT
1636   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "re-attempting connect of peer %s to peer %s\n",
1637               ctx->d1->shortname, ctx->d2->shortname);
1638 #endif
1639
1640   GNUNET_assert(ctx->d1core == NULL);
1641
1642   ctx->d1core = GNUNET_CORE_connect (ctx->d1->sched,
1643                                      ctx->d1->cfg,
1644                                      GNUNET_TIME_absolute_get_remaining(ctx->timeout),
1645                                      ctx,
1646                                      NULL,
1647                                      &connect_notify, NULL, NULL,
1648                                      NULL, GNUNET_NO,
1649                                      NULL, GNUNET_NO, no_handlers);
1650   if (ctx->d1core == NULL)
1651     {
1652       if (NULL != ctx->cb)
1653         ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg, ctx->d2->cfg, ctx->d1, ctx->d2,
1654                  _("Failed to connect to core service of first peer!\n"));
1655       GNUNET_free (ctx);
1656       return;
1657     }
1658
1659   ctx->d2th = GNUNET_TRANSPORT_connect (ctx->d2->sched,
1660                                         ctx->d2->cfg,
1661                                         &ctx->d2->id,
1662                                         ctx->d2, NULL, NULL, NULL);
1663   if (ctx->d2th == NULL)
1664     {
1665       GNUNET_CORE_disconnect(ctx->d1core);
1666       GNUNET_free (ctx);
1667       if (NULL != ctx->cb)
1668         ctx->cb (ctx->cb_cls, &ctx->d1->id, &ctx->d2->id, 0, ctx->d1->cfg, ctx->d2->cfg, ctx->d1, ctx->d2,
1669             _("Failed to connect to transport service!\n"));
1670       return;
1671     }
1672
1673   ctx->timeout_task = GNUNET_SCHEDULER_add_delayed (ctx->d1->sched,
1674                                                     GNUNET_TIME_relative_divide(ctx->relative_timeout, ctx->max_connect_attempts),
1675                                                     &notify_connect_result, ctx);
1676
1677   ctx->hello_send_task = GNUNET_SCHEDULER_add_now(ctx->d1->sched, &send_hello, ctx);
1678 }
1679
1680 /* end of testing.c */