src/dv/test_transport_api_dv.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 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  * @file dv/test_transport_api_dv.c
  22  * @brief base testcase for testing distance vector transport
  23  */
  24 #include "platform.h"
  25 #include "gnunet_testing_lib.h"
  26 #include "gnunet_core_service.h"
  27
  28 #define VERBOSE GNUNET_NO
  29
  30 #define TEST_ALL GNUNET_NO
  31
  32 /**
  33  * How long until we fail the whole testcase?
  34  */
  35 #define TEST_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
  36
  37 /**
  38  * How long until we give up on starting the peers?
  39  */
  40 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 500)
  41
  42 #define DEFAULT_NUM_PEERS 4
  43
  44 #define DEFAULT_ADDITIONAL_MESSAGES 2
  45
  46 #define MAX_OUTSTANDING_CONNECTIONS 100
  47
  48 static float fail_percentage = 0.00;
  49
  50 static int ok;
  51
  52 static unsigned long long num_additional_messages;
  53
  54 static unsigned long long num_peers;
  55
  56 static unsigned int total_connections;
  57
  58 static unsigned int failed_connections;
  59
  60 static unsigned int total_server_connections;
  61
  62 static unsigned int total_messages_received;
  63
  64 static unsigned int total_other_expected_messages;
  65
  66 static unsigned int temp_total_other_messages;
  67
  68 static unsigned int total_other_messages;
  69
  70 static unsigned int expected_messages;
  71
  72 static unsigned int expected_connections;
  73
  74 static unsigned long long peers_left;
  75
  76 static struct GNUNET_TESTING_PeerGroup *pg;
  77
  78 const struct GNUNET_CONFIGURATION_Handle *main_cfg;
  79
  80 GNUNET_SCHEDULER_TaskIdentifier die_task;
  81
  82 static char *dotOutFileName = "topology.dot";
  83
  84 static FILE *dotOutFile;
  85
  86 static char *blacklist_transports;
  87
  88 static int transmit_ready_scheduled;
  89
  90 static int transmit_ready_failed;
  91
  92 static int transmit_ready_called;
  93
  94 static enum GNUNET_TESTING_Topology topology;
  95
  96 static enum GNUNET_TESTING_Topology blacklist_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */
  97
  98 static enum GNUNET_TESTING_Topology connection_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* NONE actually means connect all allowed peers */
  99
 100 static enum GNUNET_TESTING_TopologyOption connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL;
 101
 102 static double connect_topology_option_modifier = 0.0;
 103
 104 static char *test_directory;
 105
 106 struct GNUNET_CONTAINER_MultiHashMap *peer_daemon_hash;
 107
 108 #define MTYPE 12345
 109
 110 struct GNUNET_TestMessage
 111 {
 112   /**
 113    * Header of the message
 114    */
 115   struct GNUNET_MessageHeader header;
 116
 117   /**
 118    * Unique identifier for this message.
 119    */
 120   uint32_t uid;
 121 };
 122
 123 struct PeerContext
 124 {
 125   /* This is a linked list */
 126   struct PeerContext *next;
 127
 128   /**
 129    * Handle to the daemon
 130    */
 131   struct GNUNET_TESTING_Daemon *daemon;
 132
 133   /* Handle to the peer core */
 134   struct GNUNET_CORE_Handle *peer_handle;
 135 };
 136
 137 static struct PeerContext *all_peers;
 138
 139 struct TestMessageContext
 140 {
 141   /* This is a linked list */
 142   struct TestMessageContext *next;
 143
 144   /* Handle to the sending peer core */
 145   struct GNUNET_CORE_Handle *peer1handle;
 146
 147   /* Handle to the receiving peer core */
 148   struct GNUNET_CORE_Handle *peer2handle;
 149
 150   /* Handle to the sending peer daemon */
 151   struct GNUNET_TESTING_Daemon *peer1;
 152
 153   /* Handle to the receiving peer daemon */
 154   struct GNUNET_TESTING_Daemon *peer2;
 155
 156   /* Identifier for this message, so we don't disconnect other peers! */
 157   uint32_t uid;
 158
 159   /* Task for disconnecting cores, allow task to be cancelled on shutdown */
 160   GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
 161 };
 162
 163 static struct TestMessageContext *test_messages;
 164
 165 static struct TestMessageContext *other_test_messages;
 166
 167 /**
 168  * Check whether peers successfully shut down.
 169  */
 170 void shutdown_callback (void *cls,
 171                         const char *emsg)
 172 {
 173   if (emsg != NULL)
 174     {
 175 #if VERBOSE
 176       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 177                   "Shutdown of peers failed!\n");
 178 #endif
 179       if (ok == 0)
 180         ok = 666;
 181     }
 182   else
 183     {
 184 #if VERBOSE
 185       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 186                   "All peers successfully shut down!\n");
 187 #endif
 188     }
 189 }
 190
 191 static void
 192 finish_testing ()
 193 {
 194   GNUNET_assert (pg != NULL);
 195   struct PeerContext *peer_pos;
 196   struct PeerContext *free_peer_pos;
 197   struct TestMessageContext *pos;
 198   struct TestMessageContext *free_pos;
 199
 200 #if VERBOSE
 201   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 202               "Called finish testing, stopping daemons.\n");
 203 #endif
 204   peer_pos = all_peers;
 205   while (peer_pos != NULL)
 206     {
 207       if (peer_pos->peer_handle != NULL)
 208         GNUNET_CORE_disconnect(peer_pos->peer_handle);
 209       free_peer_pos = peer_pos;
 210       peer_pos = peer_pos->next;
 211       GNUNET_free(free_peer_pos);
 212     }
 213   all_peers = NULL;
 214
 215   pos = test_messages;
 216   while (pos != NULL)
 217     {
 218       if (pos->peer1handle != NULL)
 219         {
 220           GNUNET_CORE_disconnect(pos->peer1handle);
 221           pos->peer1handle = NULL;
 222         }
 223       if (pos->peer2handle != NULL)
 224         {
 225           GNUNET_CORE_disconnect(pos->peer2handle);
 226           pos->peer2handle = NULL;
 227         }
 228       free_pos = pos;
 229       pos = pos->next;
 230       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 231         {
 232           GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
 233         }
 234       GNUNET_free(free_pos);
 235     }
 236
 237   pos = other_test_messages;
 238   while (pos != NULL)
 239     {
 240       if (pos->peer1handle != NULL)
 241         {
 242           GNUNET_CORE_disconnect(pos->peer1handle);
 243           pos->peer1handle = NULL;
 244         }
 245       if (pos->peer2handle != NULL)
 246         {
 247           GNUNET_CORE_disconnect(pos->peer2handle);
 248           pos->peer2handle = NULL;
 249         }
 250       free_pos = pos;
 251       pos = pos->next;
 252       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 253         {
 254           GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
 255         }
 256       GNUNET_free(free_pos);
 257     }
 258 #if VERBOSE
 259           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 260                       "transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n", transmit_ready_scheduled, transmit_ready_failed, transmit_ready_called);
 261 #endif
 262
 263 #if VERBOSE
 264           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 265                       "Calling daemons_stop\n");
 266 #endif
 267   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 268 #if VERBOSE
 269           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 270                       "daemons_stop finished\n");
 271 #endif
 272   if (dotOutFile != NULL)
 273     {
 274       fprintf(dotOutFile, "}");
 275       fclose(dotOutFile);
 276     }
 277
 278   ok = 0;
 279 }
 280
 281
 282 static void
 283 disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 284 {
 285   struct TestMessageContext *pos = cls;
 286
 287   /* Disconnect from the respective cores */
 288 #if VERBOSE
 289   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 290               "Disconnecting from peer 1 `%4s'\n", GNUNET_i2s (&pos->peer1->id));
 291 #endif
 292   if (pos->peer1handle != NULL)
 293     GNUNET_CORE_disconnect(pos->peer1handle);
 294 #if VERBOSE
 295   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 296               "Disconnecting from peer 2 `%4s'\n", GNUNET_i2s (&pos->peer2->id));
 297 #endif
 298   if (pos->peer2handle != NULL)
 299     GNUNET_CORE_disconnect(pos->peer2handle);
 300   /* Set handles to NULL so test case can be ended properly */
 301   pos->peer1handle = NULL;
 302   pos->peer2handle = NULL;
 303   pos->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 304   /* Decrement total connections so new can be established */
 305   total_server_connections -= 2;
 306 }
 307
 308 static void
 309 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 310 {
 311   char *msg = cls;
 312   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 313               "End badly was called (%s)... stopping daemons.\n", msg);
 314   struct TestMessageContext *pos;
 315   struct TestMessageContext *free_pos;
 316   struct PeerContext * peer_pos;
 317   struct PeerContext * free_peer_pos;
 318
 319   peer_pos = all_peers;
 320   while (peer_pos != NULL)
 321     {
 322       if (peer_pos->peer_handle != NULL)
 323         GNUNET_CORE_disconnect(peer_pos->peer_handle);
 324       free_peer_pos = peer_pos;
 325       peer_pos = peer_pos->next;
 326       GNUNET_free(free_peer_pos);
 327     }
 328   all_peers = NULL;
 329
 330   pos = test_messages;
 331   while (pos != NULL)
 332     {
 333       if (pos->peer1handle != NULL)
 334         {
 335           GNUNET_CORE_disconnect(pos->peer1handle);
 336           pos->peer1handle = NULL;
 337         }
 338       if (pos->peer2handle != NULL)
 339         {
 340           GNUNET_CORE_disconnect(pos->peer2handle);
 341           pos->peer2handle = NULL;
 342         }
 343       free_pos = pos;
 344       pos = pos->next;
 345       GNUNET_free(free_pos);
 346     }
 347
 348   pos = other_test_messages;
 349   while (pos != NULL)
 350     {
 351       if (pos->peer1handle != NULL)
 352         {
 353           GNUNET_CORE_disconnect(pos->peer1handle);
 354           pos->peer1handle = NULL;
 355         }
 356       if (pos->peer2handle != NULL)
 357         {
 358           GNUNET_CORE_disconnect(pos->peer2handle);
 359           pos->peer2handle = NULL;
 360         }
 361       free_pos = pos;
 362       pos = pos->next;
 363       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 364         {
 365           GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
 366         }
 367       GNUNET_free(free_pos);
 368     }
 369
 370   if (pg != NULL)
 371     {
 372       GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 373       ok = 7331;                /* Opposite of leet */
 374     }
 375   else
 376     ok = 401;                   /* Never got peers started */
 377
 378   if (dotOutFile != NULL)
 379     {
 380       fprintf(dotOutFile, "}");
 381       fclose(dotOutFile);
 382     }
 383 }
 384
 385 static void
 386 send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
 387
 388 static int
 389 process_mtype (void *cls,
 390                const struct GNUNET_PeerIdentity *peer,
 391                const struct GNUNET_MessageHeader *message,
 392                struct GNUNET_TIME_Relative latency,
 393                uint32_t distance)
 394 {
 395   struct TestMessageContext *pos = cls;
 396   struct GNUNET_TestMessage *msg = (struct GNUNET_TestMessage *)message;
 397   if (pos->uid != ntohl(msg->uid))
 398     return GNUNET_OK;
 399
 400   GNUNET_assert(0 == memcmp(peer, &pos->peer1->id, sizeof(struct GNUNET_PeerIdentity)));
 401   if (total_other_expected_messages == 0)
 402     {
 403       total_messages_received++;
 404 #if VERBOSE
 405       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 406                   "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance);
 407       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 408                   "Total messages received %d, expected %d.\n", total_messages_received, expected_messages);
 409 #endif
 410     }
 411   else
 412     {
 413       total_other_messages++;
 414 #if VERBOSE
 415       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 416                   "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance);
 417       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 418                   "Total messages received %d, expected %d.\n", total_other_messages, total_other_expected_messages);
 419 #endif
 420     }
 421
 422   if ((total_messages_received == expected_messages) && (total_other_messages == 0))
 423     {
 424       GNUNET_SCHEDULER_cancel (die_task);
 425       die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
 426                                                &end_badly, "waiting for DV peers to connect!");
 427       /*
 428       if ((num_peers == 3) && (total_other_expected_messages == 2))
 429         {
 430           GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);
 431         }
 432       else
 433         {
 434           GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL);
 435         }*/
 436     }
 437   else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages))
 438     {
 439       GNUNET_SCHEDULER_cancel (die_task);
 440       GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
 441     }
 442   else
 443     {
 444       pos->disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cores, pos);
 445     }
 446
 447   return GNUNET_OK;
 448 }
 449
 450 static size_t
 451 transmit_ready (void *cls, size_t size, void *buf)
 452 {
 453   struct GNUNET_TestMessage *m;
 454   struct TestMessageContext *pos = cls;
 455
 456   GNUNET_assert (buf != NULL);
 457   m = (struct GNUNET_TestMessage *) buf;
 458   m->header.type = htons (MTYPE);
 459   m->header.size = htons (sizeof (struct GNUNET_TestMessage));
 460   m->uid = htonl(pos->uid);
 461   transmit_ready_called++;
 462 #if VERBOSE
 463   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 464               "transmit ready for peer %s\ntransmit_ready's scheduled %d, transmit_ready's called %d\n", GNUNET_i2s(&pos->peer1->id), transmit_ready_scheduled, transmit_ready_called);
 465 #endif
 466   return sizeof (struct GNUNET_TestMessage);
 467 }
 468
 469
 470 static struct GNUNET_CORE_MessageHandler no_handlers[] = {
 471   {NULL, 0, 0}
 472 };
 473
 474 static struct GNUNET_CORE_MessageHandler handlers[] = {
 475   {&process_mtype, MTYPE, sizeof (struct GNUNET_TestMessage)},
 476   {NULL, 0, 0}
 477 };
 478
 479 static void
 480 init_notify_peer2 (void *cls,
 481              struct GNUNET_CORE_Handle *server,
 482              const struct GNUNET_PeerIdentity *my_identity,
 483              const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 484 {
 485   struct TestMessageContext *pos = cls;
 486
 487 #if VERBOSE
 488   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 489               "Core connection to `%4s' established, scheduling message send\n",
 490               GNUNET_i2s (my_identity));
 491 #endif
 492   total_server_connections++;
 493
 494   if (NULL == GNUNET_CORE_notify_transmit_ready (pos->peer1handle,
 495                                                  0,
 496                                                  TIMEOUT,
 497                                                  &pos->peer2->id,
 498                                                  sizeof (struct GNUNET_TestMessage),
 499                                                  &transmit_ready, pos))
 500     {
 501       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 502                   "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
 503                   GNUNET_i2s (&pos->peer2->id));
 504       transmit_ready_failed++;
 505     }
 506   else
 507     {
 508       transmit_ready_scheduled++;
 509     }
 510 }
 511
 512
 513 static void
 514 init_notify_peer1 (void *cls,
 515              struct GNUNET_CORE_Handle *server,
 516              const struct GNUNET_PeerIdentity *my_identity,
 517              const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 518 {
 519   struct TestMessageContext *pos = cls;
 520   total_server_connections++;
 521
 522 #if VERBOSE
 523   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 524               "Core connection to `%4s' established, setting up handles\n",
 525               GNUNET_i2s (my_identity));
 526 #endif
 527
 528   /*
 529    * Connect to the receiving peer
 530    */
 531   pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg,
 532                                           TIMEOUT,
 533                                           pos,
 534                                           &init_notify_peer2,
 535                                           NULL,
 536                                           NULL,
 537                                           NULL, NULL,
 538                                           GNUNET_YES, NULL, GNUNET_YES, handlers);
 539
 540 }
 541
 542
 543 static void
 544 send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 545 {
 546   struct TestMessageContext *pos = cls;
 547
 548   if ((tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN) || (cls == NULL))
 549     return;
 550
 551   if (die_task == GNUNET_SCHEDULER_NO_TASK)
 552     {
 553       die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
 554                                                &end_badly, "from create topology (timeout)");
 555     }
 556
 557   if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
 558     {
 559       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
 560                                     &send_test_messages, pos);
 561       return; /* Otherwise we'll double schedule messages here! */
 562     }
 563 #if VERBOSE
 564   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Attempting to send test message from %s to %s\n", pos->peer1->shortname, pos->peer2->shortname);
 565 #endif
 566   /*
 567    * Connect to the sending peer
 568    */
 569   pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg,
 570                                           TIMEOUT,
 571                                           pos,
 572                                           &init_notify_peer1,
 573                                           NULL, NULL,
 574                                           NULL,
 575                                           NULL,
 576                                           GNUNET_NO, NULL, GNUNET_NO, no_handlers);
 577
 578   GNUNET_assert(pos->peer1handle != NULL);
 579
 580   if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
 581     {
 582       GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next);
 583     }
 584   else
 585     {
 586       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
 587                                     &send_test_messages, pos->next);
 588     }
 589 }
 590
 591 static void
 592 send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 593 {
 594   struct TestMessageContext *pos;
 595   struct TestMessageContext *free_pos;
 596   struct PeerContext *peer_pos;
 597 #if TEST_ALL
 598   struct PeerContext *inner_peer_pos;
 599   struct TestMessageContext *temp_context;
 600 #endif
 601   peer_pos = all_peers;
 602   while (peer_pos != NULL)
 603     {
 604       if (peer_pos->peer_handle != NULL)
 605         {
 606           GNUNET_CORE_disconnect(peer_pos->peer_handle);
 607           peer_pos->peer_handle = NULL;
 608         }
 609 #if TEST_ALL
 610       inner_peer_pos = all_peers;
 611       while (inner_peer_pos != NULL)
 612         {
 613           if (inner_peer_pos != peer_pos)
 614           {
 615             temp_total_other_messages++;
 616             temp_context = GNUNET_malloc(sizeof(struct TestMessageContext));
 617             temp_context->peer1 = peer_pos->daemon;
 618             temp_context->peer2 = inner_peer_pos->daemon;
 619             temp_context->next = other_test_messages;
 620             temp_context->uid = total_connections + temp_total_other_messages;
 621             temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 622             other_test_messages = temp_context;
 623           }
 624           inner_peer_pos = inner_peer_pos->next;
 625         }
 626 #endif
 627       peer_pos = peer_pos->next;
 628     }
 629   all_peers = NULL;
 630
 631   pos = test_messages;
 632   while (pos != NULL)
 633     {
 634       if (pos->peer1handle != NULL)
 635         {
 636           GNUNET_CORE_disconnect(pos->peer1handle);
 637           pos->peer1handle = NULL;
 638         }
 639       if (pos->peer2handle != NULL)
 640         {
 641           GNUNET_CORE_disconnect(pos->peer2handle);
 642           pos->peer2handle = NULL;
 643         }
 644       free_pos = pos;
 645       pos = pos->next;
 646       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 647         {
 648           GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);
 649         }
 650       GNUNET_free(free_pos);
 651     }
 652   test_messages = NULL;
 653
 654   total_other_expected_messages = temp_total_other_messages;
 655   if (total_other_expected_messages == 0)
 656     {
 657       GNUNET_SCHEDULER_add_now (&end_badly, "send_other_messages had 0 messages to send, no DV connections made!");
 658     }
 659 #if VERBOSE
 660   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages);
 661 #endif
 662
 663   GNUNET_SCHEDULER_add_now (&send_test_messages, other_test_messages);
 664   GNUNET_SCHEDULER_cancel(die_task);
 665   die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");
 666 }
 667
 668 void
 669 topology_callback (void *cls,
 670                    const struct GNUNET_PeerIdentity *first,
 671                    const struct GNUNET_PeerIdentity *second,
 672                    uint32_t distance,
 673                    const struct GNUNET_CONFIGURATION_Handle *first_cfg,
 674                    const struct GNUNET_CONFIGURATION_Handle *second_cfg,
 675                    struct GNUNET_TESTING_Daemon *first_daemon,
 676                    struct GNUNET_TESTING_Daemon *second_daemon,
 677                    const char *emsg)
 678 {
 679   struct TestMessageContext *temp_context;
 680   if (emsg == NULL)
 681     {
 682       total_connections++;
 683 #if VERBOSE
 684       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n",
 685                first_daemon->shortname,
 686                second_daemon->shortname,
 687                distance);
 688 #endif
 689       temp_context = GNUNET_malloc(sizeof(struct TestMessageContext));
 690       temp_context->peer1 = first_daemon;
 691       temp_context->peer2 = second_daemon;
 692       temp_context->next = test_messages;
 693       temp_context->uid = total_connections;
 694       temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 695       test_messages = temp_context;
 696
 697       expected_messages++;
 698
 699     }
 700 #if VERBOSE
 701   else
 702     {
 703       failed_connections++;
 704       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n",
 705                first_daemon->shortname,
 706                second_daemon->shortname, emsg);
 707     }
 708 #endif
 709
 710   if (total_connections == expected_connections)
 711     {
 712 #if VERBOSE
 713       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 714                   "Created %u total connections, which is our target number!  Calling send messages.\n",
 715                   total_connections);
 716 #endif
 717
 718       GNUNET_SCHEDULER_cancel (die_task);
 719       die_task = GNUNET_SCHEDULER_NO_TASK;
 720       GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);
 721     }
 722   else if (total_connections + failed_connections == expected_connections)
 723     {
 724       if (failed_connections < (unsigned int)(fail_percentage * total_connections))
 725         {
 726           GNUNET_SCHEDULER_cancel (die_task);
 727           die_task = GNUNET_SCHEDULER_NO_TASK;
 728           GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);
 729         }
 730       else
 731         {
 732           GNUNET_SCHEDULER_cancel (die_task);
 733           die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
 734         }
 735     }
 736   else
 737     {
 738 #if VERBOSE
 739       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 740                   "Have %d total connections, %d failed connections, Want %d (at least %d)\n",
 741                   total_connections, failed_connections, expected_connections, expected_connections - (unsigned int)(fail_percentage * expected_connections));
 742 #endif
 743     }
 744 }
 745
 746 static void
 747 connect_topology ()
 748 {
 749   expected_connections = -1;
 750   if ((pg != NULL) && (peers_left == 0))
 751     {
 752       expected_connections = GNUNET_TESTING_connect_topology (pg, connection_topology, connect_topology_option, connect_topology_option_modifier, NULL, NULL);
 753 #if VERBOSE
 754       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 755                   "Have %d expected connections\n", expected_connections);
 756 #endif
 757     }
 758
 759   GNUNET_SCHEDULER_cancel (die_task);
 760   if (expected_connections == GNUNET_SYSERR)
 761     {
 762       die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
 763     }
 764
 765   die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
 766                                            &end_badly, "from connect topology (timeout)");
 767 }
 768
 769 static void
 770 create_topology ()
 771 {
 772   peers_left = num_peers; /* Reset counter */
 773   if (GNUNET_TESTING_create_topology (pg, topology, blacklist_topology, blacklist_transports) != GNUNET_SYSERR)
 774     {
 775 #if VERBOSE
 776       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 777                   "Topology set up, now starting peers!\n");
 778 #endif
 779       GNUNET_TESTING_daemons_continue_startup(pg);
 780     }
 781   else
 782     {
 783       GNUNET_SCHEDULER_cancel (die_task);
 784       die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
 785     }
 786   GNUNET_SCHEDULER_cancel (die_task);
 787   die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
 788                                            &end_badly, "from continue startup (timeout)");
 789 }
 790
 791 /**
 792  * Method called whenever a given peer connects.
 793  *
 794  * @param cls closure
 795  * @param peer peer identity this notification is about
 796  * @param latency reported latency of the connection with 'other'
 797  * @param distance reported distance (DV) to 'other'
 798  */
 799 static void all_connect_handler (void *cls,
 800                                  const struct
 801                                  GNUNET_PeerIdentity * peer,
 802                                  struct GNUNET_TIME_Relative latency,
 803                                  uint32_t distance)
 804 {
 805   struct GNUNET_TESTING_Daemon *d = cls;
 806   struct GNUNET_TESTING_Daemon *second_daemon;
 807   char *second_shortname = strdup(GNUNET_i2s(peer));
 808 #if !TEST_ALL
 809   struct TestMessageContext *temp_context;
 810 #endif
 811 #if VERBOSE
 812   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n",
 813            d->shortname,
 814            second_shortname,
 815            distance);
 816 #endif
 817
 818   second_daemon = GNUNET_CONTAINER_multihashmap_get(peer_daemon_hash, &peer->hashPubKey);
 819
 820   if (second_daemon == NULL)
 821     {
 822       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't find second peer!\n");
 823       GNUNET_free(second_shortname);
 824       return;
 825     }
 826 #if !TEST_ALL
 827   if (distance > 1)
 828     {
 829       temp_total_other_messages++;
 830       temp_context = GNUNET_malloc(sizeof(struct TestMessageContext));
 831       temp_context->peer1 = d;
 832       temp_context->peer2 = second_daemon;
 833       temp_context->next = other_test_messages;
 834       temp_context->uid = total_connections + temp_total_other_messages;
 835       temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 836       other_test_messages = temp_context;
 837     }
 838 #endif
 839
 840
 841   if (dotOutFile != NULL)
 842     {
 843       if (distance == 1)
 844         fprintf(dotOutFile, "\tn%s -- n%s;\n", d->shortname, second_shortname);
 845       else if (distance == 2)
 846         fprintf(dotOutFile, "\tn%s -- n%s [color=blue];\n", d->shortname, second_shortname);
 847       else if (distance == 3)
 848         fprintf(dotOutFile, "\tn%s -- n%s [color=red];\n", d->shortname, second_shortname);
 849       else if (distance == 4)
 850         fprintf(dotOutFile, "\tn%s -- n%s [color=green];\n", d->shortname, second_shortname);
 851       else
 852         fprintf(dotOutFile, "\tn%s -- n%s [color=brown];\n", d->shortname, second_shortname);
 853     }
 854   GNUNET_free(second_shortname);
 855
 856   if (temp_total_other_messages == num_additional_messages)
 857     {
 858       GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);
 859     }
 860 }
 861
 862 static void
 863 peers_started_callback (void *cls,
 864        const struct GNUNET_PeerIdentity *id,
 865        const struct GNUNET_CONFIGURATION_Handle *cfg,
 866        struct GNUNET_TESTING_Daemon *d, const char *emsg)
 867 {
 868   struct PeerContext *new_peer;
 869   if (emsg != NULL)
 870     {
 871       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to start daemon with error: `%s'\n",
 872                   emsg);
 873       return;
 874     }
 875   GNUNET_assert (id != NULL);
 876 #if VERBOSE
 877   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n",
 878               (num_peers - peers_left) + 1, num_peers);
 879 #endif
 880   GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 881
 882   new_peer = GNUNET_malloc(sizeof(struct PeerContext));
 883   new_peer->peer_handle = GNUNET_CORE_connect(cfg, GNUNET_TIME_UNIT_FOREVER_REL, d, NULL, &all_connect_handler, NULL, NULL, NULL, GNUNET_NO, NULL, GNUNET_NO, no_handlers);
 884   new_peer->daemon = d;
 885   new_peer->next = all_peers;
 886   all_peers = new_peer;
 887   peers_left--;
 888
 889   if (peers_left == 0)
 890     {
 891 #if VERBOSE
 892       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 893                   "All %d daemons started, now creating topology!\n",
 894                   num_peers);
 895 #endif
 896       GNUNET_SCHEDULER_cancel (die_task);
 897       /* Set up task in case topology creation doesn't finish
 898        * within a reasonable amount of time */
 899       die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 900                                                (GNUNET_TIME_UNIT_MINUTES, 5),
 901                                                &end_badly, "from peers_started_callback");
 902
 903       connect_topology ();
 904       ok = 0;
 905     }
 906 }
 907
 908 /**
 909  * Callback indicating that the hostkey was created for a peer.
 910  *
 911  * @param cls NULL
 912  * @param id the peer identity
 913  * @param d the daemon handle (pretty useless at this point, remove?)
 914  * @param emsg non-null on failure
 915  */
 916 void hostkey_callback (void *cls,
 917                        const struct GNUNET_PeerIdentity *id,
 918                        struct GNUNET_TESTING_Daemon *d,
 919                        const char *emsg)
 920 {
 921   if (emsg != NULL)
 922     {
 923       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Hostkey callback received error: %s\n", emsg);
 924     }
 925
 926 #if VERBOSE
 927     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 928                 "Hostkey created for peer `%s'\n",
 929                 GNUNET_i2s(id));
 930 #endif
 931     peers_left--;
 932     if (peers_left == 0)
 933       {
 934 #if VERBOSE
 935         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 936                     "All %d hostkeys created, now creating topology!\n",
 937                     num_peers);
 938 #endif
 939         GNUNET_SCHEDULER_cancel (die_task);
 940         /* Set up task in case topology creation doesn't finish
 941          * within a reasonable amount of time */
 942         die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 943                                                  (GNUNET_TIME_UNIT_MINUTES, 5),
 944                                                  &end_badly, "from hostkey_callback");
 945         GNUNET_SCHEDULER_add_now(&create_topology, NULL);
 946         ok = 0;
 947       }
 948 }
 949
 950 static void
 951 run (void *cls,
 952      char *const *args,
 953      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 954 {
 955   char * topology_str;
 956   char * connect_topology_str;
 957   char * blacklist_topology_str;
 958   char * connect_topology_option_str;
 959   char * connect_topology_option_modifier_string;
 960   ok = 1;
 961
 962   dotOutFile = fopen (dotOutFileName, "w");
 963   if (dotOutFile != NULL)
 964     {
 965       fprintf (dotOutFile, "strict graph G {\n");
 966     }
 967
 968 #if VERBOSE
 969   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 970               "Starting daemons based on config file %s\n", cfgfile);
 971 #endif
 972
 973   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
 974     {
 975       ok = 404;
 976       return;
 977     }
 978
 979   if ((GNUNET_YES ==
 980       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "topology",
 981                                             &topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&topology, topology_str)))
 982     {
 983       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 984                   "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "TOPOLOGY");
 985       topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */
 986     }
 987
 988   if ((GNUNET_YES ==
 989       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology",
 990                                             &connect_topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&connection_topology, connect_topology_str)))
 991     {
 992       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 993                   "Invalid connect topology `%s' given for section %s option %s\n", connect_topology_str, "TESTING", "CONNECT_TOPOLOGY");
 994     }
 995   GNUNET_free_non_null(connect_topology_str);
 996   if ((GNUNET_YES ==
 997       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology_option",
 998                                             &connect_topology_option_str)) && (GNUNET_NO == GNUNET_TESTING_topology_option_get(&connect_topology_option, connect_topology_option_str)))
 999     {
1000       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1001                   "Invalid connect topology option `%s' given for section %s option %s\n", connect_topology_option_str, "TESTING", "CONNECT_TOPOLOGY_OPTION");
1002       connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */
1003     }
1004   GNUNET_free_non_null(connect_topology_option_str);
1005   if (GNUNET_YES ==
1006         GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "connect_topology_option_modifier",
1007                                                &connect_topology_option_modifier_string))
1008     {
1009       if (sscanf(connect_topology_option_modifier_string, "%lf", &connect_topology_option_modifier) != 1)
1010       {
1011         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1012         _("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
1013         connect_topology_option_modifier_string,
1014         "connect_topology_option_modifier",
1015         "TESTING");
1016       }
1017       GNUNET_free (connect_topology_option_modifier_string);
1018     }
1019
1020   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "blacklist_transports",
1021                                          &blacklist_transports))
1022     blacklist_transports = NULL;
1023
1024   if ((GNUNET_YES ==
1025       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "blacklist_topology",
1026                                             &blacklist_topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&blacklist_topology, blacklist_topology_str)))
1027     {
1028       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1029                   "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "BLACKLIST_TOPOLOGY");
1030     }
1031   GNUNET_free_non_null(topology_str);
1032   GNUNET_free_non_null(blacklist_topology_str);
1033   if (GNUNET_SYSERR ==
1034       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
1035                                              &num_peers))
1036     num_peers = DEFAULT_NUM_PEERS;
1037
1038   if (GNUNET_SYSERR ==
1039       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "additional_messages",
1040                                              &num_additional_messages))
1041     num_additional_messages = DEFAULT_ADDITIONAL_MESSAGES;
1042
1043   main_cfg = cfg;
1044
1045   GNUNET_assert(num_peers > 0 && num_peers < (unsigned int)-1);
1046   peers_left = num_peers;
1047
1048   /* Set up a task to end testing if peer start fails */
1049   die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
1050                                            (GNUNET_TIME_UNIT_MINUTES, 5),
1051                                            &end_badly, "didn't start all daemons in reasonable amount of time!!!");
1052
1053   peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left);
1054   pg = GNUNET_TESTING_daemons_start (cfg,
1055                                      peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
1056                                      &topology_callback, NULL, NULL);
1057
1058 }
1059
1060 static int
1061 check ()
1062 {
1063   int ret;
1064   char *const argv[] = {"test-transport-dv",
1065     "-c",
1066     "test_transport_dv_data.conf",
1067 #if VERBOSE
1068     "-L", "DEBUG",
1069 #endif
1070     NULL
1071   };
1072   struct GNUNET_GETOPT_CommandLineOption options[] = {
1073     GNUNET_GETOPT_OPTION_END
1074   };
1075   ret = GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
1076                       argv, "test-transport-dv", "nohelp",
1077                       options, &run, &ok);
1078   if (ret != GNUNET_OK)
1079     {
1080       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`test-transport-dv': Failed with error code %d\n", ret);
1081     }
1082   return ok;
1083 }
1084
1085 int
1086 main (int argc, char *argv[])
1087 {
1088   int ret;
1089
1090   GNUNET_log_setup ("test-transport-dv",
1091 #if VERBOSE
1092                     "DEBUG",
1093 #else
1094                     "WARNING",
1095 #endif
1096                     NULL);
1097   ret = check ();
1098   /**
1099    * Need to remove base directory, subdirectories taken care
1100    * of by the testing framework.
1101    */
1102   if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
1103     {
1104       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory);
1105     }
1106   return ret;
1107 }
1108
1109 /* end of test_transport_api_dv.c */