src/dht/gnunet-dht-driver.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 dht/gnunet-dht-driver.c
  22  * @brief Driver for setting up a group of gnunet peers and
  23  *        then issuing GETS and PUTS on the DHT.  Coarse results
  24  *        are reported, fine grained results (if requested) are
  25  *        logged to a (mysql) database, or to file.
  26  * @author Nathan Evans (who to blame)
  27  */
  28 #include "platform.h"
  29 #ifndef HAVE_MALICIOUS
  30 #error foo
  31 #endif
  32 #include "gnunet_testing_lib.h"
  33 #include "gnunet_core_service.h"
  34 #include "gnunet_dht_service.h"
  35 #include "dhtlog.h"
  36 #include "dht.h"
  37
  38 /* DEFINES */
  39 #define VERBOSE GNUNET_NO
  40
  41 /* Timeout for entire driver to run */
  42 #define DEFAULT_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
  43
  44 /* Timeout for waiting for (individual) replies to get requests */
  45 #define DEFAULT_GET_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)
  46
  47 #define DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)
  48
  49 /* Timeout for waiting for gets to be sent to the service */
  50 #define DEFAULT_GET_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
  51
  52 /* Timeout for waiting for puts to be sent to the service */
  53 #define DEFAULT_PUT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
  54
  55 /* Time to allow a find peer request to take */
  56 #define DEFAULT_FIND_PEER_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 40)
  57
  58 /* Time to wait for all peers disconnected due to to churn to actually be removed from system */
  59 #define DEFAULT_PEER_DISCONNECT_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
  60
  61 #define DEFAULT_SECONDS_PER_PEER_START GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 45)
  62
  63 #define DEFAULT_TEST_DATA_SIZE 8
  64
  65 #define DEFAULT_BUCKET_SIZE 4
  66
  67 #define FIND_PEER_THRESHOLD 1
  68
  69 /* If more than this many peers are added, slow down sending */
  70 #define MAX_FIND_PEER_CUTOFF 4000
  71
  72 /* If less than this many peers are added, speed up sending */
  73 #define MIN_FIND_PEER_CUTOFF 500
  74
  75 #define DEFAULT_MAX_OUTSTANDING_PUTS 10
  76
  77 #define DEFAULT_MAX_OUTSTANDING_FIND_PEERS 196
  78
  79 #define DEFAULT_FIND_PEER_OFFSET GNUNET_TIME_relative_divide (DEFAULT_FIND_PEER_DELAY, DEFAULT_MAX_OUTSTANDING_FIND_PEERS)
  80
  81 #define DEFAULT_MAX_OUTSTANDING_GETS 10
  82
  83 #define DEFAULT_CONNECT_TIMEOUT 60
  84
  85 #define DEFAULT_TOPOLOGY_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 8)
  86
  87 #define DEFAULT_RECONNECT_ATTEMPTS 8
  88
  89 /*
  90  * Default frequency for sending malicious get messages
  91  */
  92 #define DEFAULT_MALICIOUS_GET_FREQUENCY GNUNET_TIME_UNIT_SECONDS
  93
  94 /*
  95  * Default frequency for sending malicious put messages
  96  */
  97 #define DEFAULT_MALICIOUS_PUT_FREQUENCY GNUNET_TIME_UNIT_SECONDS
  98
  99 /* Structs */
 100
 101 struct MaliciousContext
 102 {
 103   /**
 104    * Handle to DHT service (via the API)
 105    */
 106   struct GNUNET_DHT_Handle *dht_handle;
 107
 108   /**
 109    *  Handle to the peer daemon
 110    */
 111   struct GNUNET_TESTING_Daemon *daemon;
 112
 113   /**
 114    * Task for disconnecting DHT handles
 115    */
 116   GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
 117
 118   /**
 119    * What type of malicious to set this peer to.
 120    */
 121   int malicious_type;
 122 };
 123
 124 struct TestFindPeer
 125 {
 126   /* This is a linked list */
 127   struct TestFindPeer *next;
 128
 129   /* Handle to the bigger context */
 130   struct FindPeerContext *find_peer_context;
 131
 132   /**
 133    * Handle to the peer's DHT service (via the API)
 134    */
 135   struct GNUNET_DHT_Handle *dht_handle;
 136
 137   /**
 138    *  Handle to the peer daemon
 139    */
 140   struct GNUNET_TESTING_Daemon *daemon;
 141
 142   /**
 143    * Task for disconnecting DHT handles
 144    */
 145   GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
 146 };
 147
 148 struct TestPutContext
 149 {
 150   /* This is a linked list */
 151   struct TestPutContext *next;
 152
 153   /**
 154    * Handle to the first peers DHT service (via the API)
 155    */
 156   struct GNUNET_DHT_Handle *dht_handle;
 157
 158   /**
 159    *  Handle to the PUT peer daemon
 160    */
 161   struct GNUNET_TESTING_Daemon *daemon;
 162
 163   /**
 164    *  Identifier for this PUT
 165    */
 166   uint32_t uid;
 167
 168   /**
 169    * Task for disconnecting DHT handles
 170    */
 171   GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
 172 };
 173
 174 struct TestGetContext
 175 {
 176   /* This is a linked list */
 177   struct TestGetContext *next;
 178
 179   /**
 180    * Handle to the first peers DHT service (via the API)
 181    */
 182   struct GNUNET_DHT_Handle *dht_handle;
 183
 184   /**
 185    * Handle for the DHT get request
 186    */
 187   struct GNUNET_DHT_GetHandle *get_handle;
 188
 189   /**
 190    *  Handle to the GET peer daemon
 191    */
 192   struct GNUNET_TESTING_Daemon *daemon;
 193
 194   /**
 195    *  Identifier for this GET
 196    */
 197   uint32_t uid;
 198
 199   /**
 200    * Task for disconnecting DHT handles (and stopping GET)
 201    */
 202   GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
 203
 204   /**
 205    * Whether or not this request has been fulfilled already.
 206    */
 207   int succeeded;
 208 };
 209
 210 /**
 211  * Simple struct to keep track of progress, and print a
 212  * nice little percentage meter for long running tasks.
 213  */
 214 struct ProgressMeter
 215 {
 216   unsigned int total;
 217
 218   unsigned int modnum;
 219
 220   unsigned int dotnum;
 221
 222   unsigned int completed;
 223
 224   int print;
 225
 226   char *startup_string;
 227 };
 228
 229 /**
 230  * Linked list of information for populating statistics
 231  * before ending trial.
 232  */
 233 struct StatisticsIteratorContext
 234 {
 235   const struct GNUNET_PeerIdentity *peer;
 236   unsigned int stat_routes;
 237   unsigned int stat_route_forwards;
 238   unsigned int stat_results;
 239   unsigned int stat_results_to_client;
 240   unsigned int stat_result_forwards;
 241   unsigned int stat_gets;
 242   unsigned int stat_puts;
 243   unsigned int stat_puts_inserted;
 244   unsigned int stat_find_peer;
 245   unsigned int stat_find_peer_start;
 246   unsigned int stat_get_start;
 247   unsigned int stat_put_start;
 248   unsigned int stat_find_peer_reply;
 249   unsigned int stat_get_reply;
 250   unsigned int stat_find_peer_answer;
 251   unsigned int stat_get_response_start;
 252 };
 253
 254 /**
 255  * Context for getting a topology, logging it, and continuing
 256  * on with some next operation.
 257  */
 258 struct TopologyIteratorContext
 259 {
 260   unsigned int total_iterations;
 261   unsigned int current_iteration;
 262   unsigned int total_connections;
 263   unsigned int total_peers;
 264   struct GNUNET_CONTAINER_MultiHashMap *peers_seen;
 265   struct GNUNET_PeerIdentity *peer;
 266   GNUNET_SCHEDULER_Task cont;
 267   void *cls;
 268   struct GNUNET_TIME_Relative timeout;
 269 };
 270
 271
 272 struct PeerCount
 273 {
 274   /** Node in the heap */
 275   struct GNUNET_CONTAINER_HeapNode *heap_node;
 276
 277   /** Peer the count refers to */
 278   struct GNUNET_PeerIdentity peer_id;
 279
 280   /** Count of connections this peer has */
 281   unsigned int count;
 282 };
 283
 284 /**
 285  * Context for sending out find peer requests.
 286  */
 287 struct FindPeerContext
 288 {
 289   /**
 290    * How long to send find peer requests, once the settle time
 291    * is over don't send any more out!
 292    *
 293    * TODO: Add option for settle time and find peer sending time?
 294    */
 295   struct GNUNET_TIME_Absolute endtime;
 296
 297   /**
 298    * Number of connections in the current topology
 299    * (after this round of find peer requests has ended).
 300    */
 301   unsigned int current_peers;
 302
 303   /**
 304    * Number of connections in the current topology
 305    * (before this round of find peer requests started).
 306    */
 307   unsigned int previous_peers;
 308
 309   /**
 310    * Number of find peer requests we have currently
 311    * outstanding.
 312    */
 313   unsigned int outstanding;
 314
 315   /**
 316    * Number of find peer requests to send in this round.
 317    */
 318   unsigned int total;
 319
 320   /**
 321    * Number of find peer requests sent last time around.
 322    */
 323   unsigned int last_sent;
 324
 325   /**
 326    * Hashmap of peers in the current topology, value
 327    * is a PeerCount, with the number of connections
 328    * this peer has.
 329    */
 330   struct GNUNET_CONTAINER_MultiHashMap *peer_hash;
 331
 332   /**
 333    * Min heap which orders values in the peer_hash for
 334    * easy lookup.
 335    */
 336   struct GNUNET_CONTAINER_Heap *peer_min_heap;
 337
 338   /**
 339    * Callback for counting the peers in the current topology.
 340    */
 341   GNUNET_TESTING_NotifyTopology count_peers_cb;
 342 };
 343
 344 enum DHT_ROUND_TYPES
 345 {
 346   /**
 347    * Next full round (puts + gets).
 348    */
 349   DHT_ROUND_NORMAL,
 350
 351   /**
 352    * Next round of gets.
 353    */
 354   DHT_ROUND_GET,
 355
 356   /**
 357    * Next round of puts.
 358    */
 359   DHT_ROUND_PUT,
 360
 361   /**
 362    * Next round of churn.
 363    */
 364   DHT_ROUND_CHURN
 365 };
 366
 367
 368
 369 /* Globals */
 370
 371 /**
 372  * Timeout to let all GET requests happen.
 373  */
 374 static struct GNUNET_TIME_Relative all_get_timeout;
 375
 376 /**
 377  * Per get timeout
 378  */
 379 static struct GNUNET_TIME_Relative get_timeout;
 380
 381 /**
 382  * Time to allow for GET requests to be sent to service.
 383  */
 384 static struct GNUNET_TIME_Relative get_delay;
 385
 386 /**
 387  * Time to allow for PUT requests to be sent to service.
 388  */
 389 static struct GNUNET_TIME_Relative put_delay;
 390
 391 /**
 392  * Delay between sending find peer requests (if
 393  * handled by the driver, no effect if sent by service).
 394  */
 395 static struct GNUNET_TIME_Relative find_peer_delay;
 396
 397 /**
 398  * Time between find peer requests
 399  * (find_peer_delay / max_outstanding_find_peer)
 400  */
 401 static struct GNUNET_TIME_Relative find_peer_offset;
 402
 403 /**
 404  * How many seconds to allow each peer to start.
 405  */
 406 static struct GNUNET_TIME_Relative seconds_per_peer_start;
 407
 408 /**
 409  * Boolean value, should the driver issue find peer requests
 410  * (GNUNET_YES) or should it be left to the service (GNUNET_NO)
 411  */
 412 static unsigned int do_find_peer;
 413
 414 /**
 415  * Boolean value, should replication be done by the dht
 416  * service (GNUNET_YES) or by the driver (GNUNET_NO)
 417  */
 418 static unsigned int in_dht_replication;
 419
 420 /**
 421  * Size of test data to insert/retrieve during testing.
 422  */
 423 static unsigned long long test_data_size = DEFAULT_TEST_DATA_SIZE;
 424
 425 /**
 426  * Maximum number of concurrent PUT requests.
 427  */
 428 static unsigned long long max_outstanding_puts = DEFAULT_MAX_OUTSTANDING_PUTS;
 429
 430 /**
 431  * Maximum number of concurrent GET requests.
 432  */
 433 static unsigned long long max_outstanding_gets = DEFAULT_MAX_OUTSTANDING_GETS;
 434
 435 /**
 436  * Number of nodes issuing malicious GET messages.
 437  */
 438 static unsigned long long malicious_getters;
 439
 440 /**
 441  * Maximum number of concurrent find peer messages being sent.
 442  */
 443 static unsigned long long max_outstanding_find_peers;
 444
 445 /**
 446  * Number of nodes issuing malicious PUT messages.
 447  */
 448 static unsigned long long malicious_putters;
 449
 450 /**
 451  * Time (in seconds) to delay between rounds.
 452  */
 453 static unsigned long long round_delay;
 454
 455 /**
 456  * How many malicious droppers to seed in the network.
 457  */
 458 static unsigned long long malicious_droppers;
 459
 460 /**
 461  * How often to send malicious GET messages.
 462  */
 463 static struct GNUNET_TIME_Relative malicious_get_frequency;
 464
 465 /**
 466  * How often to send malicious PUT messages.
 467  */
 468 static struct GNUNET_TIME_Relative malicious_put_frequency;
 469
 470 /**
 471  * How long to send find peer requests.
 472  */
 473 static unsigned long long settle_time;
 474
 475 /**
 476  * Handle to the dhtlog service.
 477  */
 478 static struct GNUNET_DHTLOG_Handle *dhtlog_handle;
 479
 480 /**
 481  * Replication value for GET requests.
 482  */
 483 static unsigned long long get_replication;
 484
 485 /**
 486  * Replication value for PUT requests.
 487  */
 488 static unsigned long long put_replication;
 489
 490 /**
 491  * If GNUNET_YES, insert data at the same peers every time.
 492  * Otherwise, choose a new random peer to insert at each time.
 493  */
 494 static unsigned int replicate_same;
 495
 496 /**
 497  * If GNUNET_YES, issue GET requests at the same peers every time.
 498  * Otherwise, choose a new random peer/data combination to search
 499  * each time.
 500  */
 501 static unsigned int get_from_same;
 502
 503 /**
 504  * Number of rounds for testing (PUTS + GETS)
 505  */
 506 static unsigned long long total_rounds;
 507
 508 /**
 509  * Number of rounds already run
 510  */
 511 static unsigned int rounds_finished;
 512
 513 /**
 514  * Number of rounds of churn to read from the file (first line, should be a single number).
 515  */
 516 static unsigned int churn_rounds;
 517
 518 /**
 519  * Current round we are in for churn, tells us how many peers to connect/disconnect.
 520  */
 521 static unsigned int current_churn_round;
 522
 523 /**
 524  * Number of times to churn per round
 525  */
 526 static unsigned long long churns_per_round;
 527
 528 /**
 529  * Array of churn values.
 530  */
 531 static unsigned int *churn_array;
 532
 533 /**
 534  * Hash map of stats contexts.
 535  */
 536 static struct GNUNET_CONTAINER_MultiHashMap *stats_map;
 537
 538 /**
 539  * LL of malicious settings.
 540  */
 541 struct MaliciousContext *all_malicious;
 542
 543 /**
 544  * List of GETS to perform
 545  */
 546 struct TestGetContext *all_gets;
 547
 548 /**
 549  * List of PUTS to perform
 550  */
 551 struct TestPutContext *all_puts;
 552
 553 /**
 554  * Directory to store temporary data in, defined in config file
 555  */
 556 static char *test_directory;
 557
 558 /**
 559  * Variable used to store the number of connections we should wait for.
 560  */
 561 static unsigned int expected_connections;
 562
 563 /**
 564  * Variable used to keep track of how many peers aren't yet started.
 565  */
 566 static unsigned long long peers_left;
 567
 568 /**
 569  * Handle to the set of all peers run for this test.
 570  */
 571 static struct GNUNET_TESTING_PeerGroup *pg;
 572
 573
 574 /**
 575  * Global config handle.
 576  */
 577 static const struct GNUNET_CONFIGURATION_Handle *config;
 578
 579 /**
 580  * Total number of peers to run, set based on config file.
 581  */
 582 static unsigned long long num_peers;
 583
 584 /**
 585  * Total number of items to insert.
 586  */
 587 static unsigned long long num_puts;
 588
 589 /**
 590  * How many puts do we currently have in flight?
 591  */
 592 static unsigned long long outstanding_puts;
 593
 594 /**
 595  * How many puts are done?
 596  */
 597 static unsigned long long puts_completed;
 598
 599 /**
 600  * Total number of items to attempt to get.
 601  */
 602 static unsigned long long num_gets;
 603
 604 /**
 605  * How many puts do we currently have in flight?
 606  */
 607 static unsigned long long outstanding_gets;
 608
 609 /**
 610  * How many gets are done?
 611  */
 612 static unsigned long long gets_completed;
 613
 614 /**
 615  * How many gets failed?
 616  */
 617 static unsigned long long gets_failed;
 618
 619 /**
 620  * How many malicious control messages do
 621  * we currently have in flight?
 622  */
 623 static unsigned long long outstanding_malicious;
 624
 625 /**
 626  * How many set malicious peers are done?
 627  */
 628 static unsigned long long malicious_completed;
 629
 630 /**
 631  * Global used to count how many connections we have currently
 632  * been notified about (how many times has topology_callback been called
 633  * with success?)
 634  */
 635 static unsigned int total_connections;
 636
 637 /**
 638  * Global used to count how many failed connections we have
 639  * been notified about (how many times has topology_callback
 640  * been called with failure?)
 641  */
 642 static unsigned int failed_connections;
 643
 644 /* Task handle to use to schedule shutdown if something goes wrong */
 645 GNUNET_SCHEDULER_TaskIdentifier die_task;
 646
 647 static char *blacklist_transports;
 648
 649 static enum GNUNET_TESTING_Topology topology;
 650
 651 static enum GNUNET_TESTING_Topology blacklist_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */
 652
 653 static enum GNUNET_TESTING_Topology connect_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* NONE actually means connect all allowed peers */
 654
 655 static enum GNUNET_TESTING_TopologyOption connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL;
 656
 657 static double connect_topology_option_modifier = 0.0;
 658
 659 static struct ProgressMeter *hostkey_meter;
 660
 661 static struct ProgressMeter *peer_start_meter;
 662
 663 static struct ProgressMeter *peer_connect_meter;
 664
 665 static struct ProgressMeter *put_meter;
 666
 667 static struct ProgressMeter *get_meter;
 668
 669 static GNUNET_HashCode *known_keys;
 670
 671 /* Global return value (0 for success, anything else for failure) */
 672 static int ok;
 673
 674 /**
 675  * Create a meter to keep track of the progress of some task.
 676  *
 677  * @param total the total number of items to complete
 678  * @param start_string a string to prefix the meter with (if printing)
 679  * @param print GNUNET_YES to print the meter, GNUNET_NO to count
 680  *              internally only
 681  *
 682  * @return the progress meter
 683  */
 684 static struct ProgressMeter *
 685 create_meter(unsigned int total, char * start_string, int print)
 686 {
 687   struct ProgressMeter *ret;
 688   ret = GNUNET_malloc(sizeof(struct ProgressMeter));
 689   ret->print = print;
 690   ret->total = total;
 691   ret->modnum = total / 4;
 692   ret->dotnum = (total / 50) + 1;
 693   if (start_string != NULL)
 694     ret->startup_string = GNUNET_strdup(start_string);
 695   else
 696     ret->startup_string = GNUNET_strdup("");
 697
 698   return ret;
 699 }
 700
 701 /**
 702  * Update progress meter (increment by one).
 703  *
 704  * @param meter the meter to update and print info for
 705  *
 706  * @return GNUNET_YES if called the total requested,
 707  *         GNUNET_NO if more items expected
 708  */
 709 static int
 710 update_meter(struct ProgressMeter *meter)
 711 {
 712   if (meter->print == GNUNET_YES)
 713     {
 714       if (meter->completed % meter->modnum == 0)
 715         {
 716           if (meter->completed == 0)
 717             {
 718               fprintf(stdout, "%sProgress: [0%%", meter->startup_string);
 719             }
 720           else
 721             fprintf(stdout, "%d%%", (int)(((float)meter->completed / meter->total) * 100));
 722         }
 723       else if (meter->completed % meter->dotnum == 0)
 724         fprintf(stdout, ".");
 725
 726       if (meter->completed + 1 == meter->total)
 727         fprintf(stdout, "%d%%]\n", 100);
 728       fflush(stdout);
 729     }
 730   meter->completed++;
 731
 732   if (meter->completed == meter->total)
 733     return GNUNET_YES;
 734   return GNUNET_NO;
 735 }
 736
 737 /**
 738  * Reset progress meter.
 739  *
 740  * @param meter the meter to reset
 741  *
 742  * @return GNUNET_YES if meter reset,
 743  *         GNUNET_SYSERR on error
 744  */
 745 static int
 746 reset_meter(struct ProgressMeter *meter)
 747 {
 748   if (meter == NULL)
 749     return GNUNET_SYSERR;
 750
 751   meter->completed = 0;
 752   return GNUNET_YES;
 753 }
 754
 755 /**
 756  * Release resources for meter
 757  *
 758  * @param meter the meter to free
 759  */
 760 static void
 761 free_meter(struct ProgressMeter *meter)
 762 {
 763   GNUNET_free_non_null (meter->startup_string);
 764   GNUNET_free (meter);
 765 }
 766
 767 /**
 768  * Check whether peers successfully shut down.
 769  */
 770 static void
 771 shutdown_callback (void *cls,
 772                    const char *emsg)
 773 {
 774   if (emsg != NULL)
 775     {
 776       if (ok == 0)
 777         ok = 2;
 778     }
 779 }
 780
 781 /**
 782  * Task to release DHT handles for PUT
 783  */
 784 static void
 785 put_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 786 {
 787   struct TestPutContext *test_put = cls;
 788   test_put->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
 789   GNUNET_DHT_disconnect(test_put->dht_handle);
 790   test_put->dht_handle = NULL;
 791   test_put->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers));
 792 }
 793
 794 /**
 795  * Function scheduled to be run on the successful completion of this
 796  * testcase.
 797  */
 798 static void
 799 finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 800 {
 801   GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Ending test normally!\n", (char *)cls);
 802   GNUNET_assert (pg != NULL);
 803   struct TestPutContext *test_put = all_puts;
 804   struct TestGetContext *test_get = all_gets;
 805
 806   while (test_put != NULL)
 807     {
 808       if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 809         GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
 810       if (test_put->dht_handle != NULL)
 811         GNUNET_DHT_disconnect(test_put->dht_handle);
 812       test_put = test_put->next;
 813     }
 814
 815   while (test_get != NULL)
 816     {
 817       if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
 818         GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
 819       if (test_get->get_handle != NULL)
 820         GNUNET_DHT_get_stop(test_get->get_handle);
 821       if (test_get->dht_handle != NULL)
 822         GNUNET_DHT_disconnect(test_get->dht_handle);
 823       test_get = test_get->next;
 824     }
 825
 826   GNUNET_TESTING_daemons_stop (pg, DEFAULT_TIMEOUT, &shutdown_callback, NULL);
 827
 828   if (dhtlog_handle != NULL)
 829     {
 830       fprintf(stderr, "Update trial endtime\n");
 831       dhtlog_handle->update_trial (gets_completed);
 832       GNUNET_DHTLOG_disconnect(dhtlog_handle);
 833       dhtlog_handle = NULL;
 834     }
 835
 836   if (hostkey_meter != NULL)
 837     free_meter(hostkey_meter);
 838   if (peer_start_meter != NULL)
 839     free_meter(peer_start_meter);
 840   if (peer_connect_meter != NULL)
 841     free_meter(peer_connect_meter);
 842   if (put_meter != NULL)
 843     free_meter(put_meter);
 844   if (get_meter != NULL)
 845     free_meter(get_meter);
 846
 847   ok = 0;
 848 }
 849
 850 /**
 851  * Callback for iterating over all the peer connections of a peer group.
 852  */
 853 static void
 854 log_topology_cb (void *cls,
 855                  const struct GNUNET_PeerIdentity *first,
 856                  const struct GNUNET_PeerIdentity *second,
 857                  const char *emsg)
 858 {
 859   struct TopologyIteratorContext *topo_ctx = cls;
 860   if ((first != NULL) && (second != NULL))
 861     {
 862       /* GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "According to CORE, peer %s is connected to %s\n", GNUNET_i2s(first), GNUNET_h2s(&second->hashPubKey));*/
 863       if ((topo_ctx->peers_seen != NULL) && (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(topo_ctx->peers_seen, &first->hashPubKey)))
 864         {
 865           GNUNET_CONTAINER_multihashmap_put(topo_ctx->peers_seen, &first->hashPubKey, NULL, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 866           topo_ctx->total_peers++;
 867         }
 868       topo_ctx->total_connections++;
 869       if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(config, "dht_testing", "mysql_logging"))
 870         dhtlog_handle->insert_extended_topology(first, second);
 871     }
 872   else
 873     {
 874       GNUNET_assert(dhtlog_handle != NULL);
 875       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Topology iteration (%u/%u) finished (%u connections, %u peers)\n", topo_ctx->current_iteration, topo_ctx->total_iterations, topo_ctx->total_connections, topo_ctx->total_peers);
 876       dhtlog_handle->update_topology(topo_ctx->total_connections);
 877       if (topo_ctx->cont != NULL)
 878         GNUNET_SCHEDULER_add_now (topo_ctx->cont, topo_ctx->cls);
 879       if (topo_ctx->peers_seen != NULL)
 880         GNUNET_CONTAINER_multihashmap_destroy(topo_ctx->peers_seen);
 881       GNUNET_free(topo_ctx);
 882     }
 883 }
 884
 885 /**
 886  * Iterator over hash map entries.
 887  *
 888  * @param cls closure - always NULL
 889  * @param key current key code
 890  * @param value value in the hash map, a stats context
 891  * @return GNUNET_YES if we should continue to
 892  *         iterate,
 893  *         GNUNET_NO if not.
 894  */
 895 static int stats_iterate (void *cls,
 896                           const GNUNET_HashCode * key,
 897                           void *value)
 898 {
 899   struct StatisticsIteratorContext *stats_ctx;
 900   if (value == NULL)
 901     return GNUNET_NO;
 902   stats_ctx = value;
 903   dhtlog_handle->insert_stat(stats_ctx->peer, stats_ctx->stat_routes, stats_ctx->stat_route_forwards, stats_ctx->stat_results,
 904                              stats_ctx->stat_results_to_client, stats_ctx->stat_result_forwards, stats_ctx->stat_gets,
 905                              stats_ctx->stat_puts, stats_ctx->stat_puts_inserted, stats_ctx->stat_find_peer,
 906                              stats_ctx->stat_find_peer_start, stats_ctx->stat_get_start, stats_ctx->stat_put_start,
 907                              stats_ctx->stat_find_peer_reply, stats_ctx->stat_get_reply, stats_ctx->stat_find_peer_answer,
 908                              stats_ctx->stat_get_response_start);
 909   GNUNET_free(stats_ctx);
 910   return GNUNET_YES;
 911 }
 912
 913 static void
 914 stats_finished (void *cls, int result)
 915 {
 916   fprintf(stderr, "Finished getting all peers statistics, iterating!\n");
 917   GNUNET_CONTAINER_multihashmap_iterate(stats_map, &stats_iterate, NULL);
 918   GNUNET_CONTAINER_multihashmap_destroy(stats_map);
 919   GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
 920 }
 921
 922 /**
 923  * Callback function to process statistic values.
 924  *
 925  * @param cls closure
 926  * @param peer the peer the statistics belong to
 927  * @param subsystem name of subsystem that created the statistic
 928  * @param name the name of the datum
 929  * @param value the current value
 930  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
 931  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
 932  */
 933 static int stats_handle  (void *cls,
 934                           const struct GNUNET_PeerIdentity *peer,
 935                           const char *subsystem,
 936                           const char *name,
 937                           uint64_t value,
 938                           int is_persistent)
 939 {
 940   struct StatisticsIteratorContext *stats_ctx;
 941
 942   if (dhtlog_handle != NULL)
 943     dhtlog_handle->add_generic_stat(peer, name, subsystem, value);
 944   if (GNUNET_CONTAINER_multihashmap_contains(stats_map, &peer->hashPubKey))
 945     {
 946       stats_ctx = GNUNET_CONTAINER_multihashmap_get(stats_map, &peer->hashPubKey);
 947     }
 948   else
 949     {
 950       stats_ctx = GNUNET_malloc(sizeof(struct StatisticsIteratorContext));
 951       stats_ctx->peer = peer;
 952       GNUNET_CONTAINER_multihashmap_put(stats_map, &peer->hashPubKey, stats_ctx, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 953     }
 954   GNUNET_assert(stats_ctx != NULL);
 955
 956   if (strcmp(name, STAT_ROUTES) == 0)
 957     stats_ctx->stat_routes = value;
 958   else if (strcmp(name, STAT_ROUTE_FORWARDS) == 0)
 959     stats_ctx->stat_route_forwards = value;
 960   else if (strcmp(name, STAT_RESULTS) == 0)
 961     stats_ctx->stat_results = value;
 962   else if (strcmp(name, STAT_RESULTS_TO_CLIENT) == 0)
 963     stats_ctx->stat_results_to_client = value;
 964   else if (strcmp(name, STAT_RESULT_FORWARDS) == 0)
 965     stats_ctx->stat_result_forwards = value;
 966   else if (strcmp(name, STAT_GETS) == 0)
 967     stats_ctx->stat_gets = value;
 968   else if (strcmp(name, STAT_PUTS) == 0)
 969     stats_ctx->stat_puts = value;
 970   else if (strcmp(name, STAT_PUTS_INSERTED) == 0)
 971     stats_ctx->stat_puts_inserted = value;
 972   else if (strcmp(name, STAT_FIND_PEER) == 0)
 973     stats_ctx->stat_find_peer = value;
 974   else if (strcmp(name, STAT_FIND_PEER_START) == 0)
 975     stats_ctx->stat_find_peer_start = value;
 976   else if (strcmp(name, STAT_GET_START) == 0)
 977     stats_ctx->stat_get_start = value;
 978   else if (strcmp(name, STAT_PUT_START) == 0)
 979     stats_ctx->stat_put_start = value;
 980   else if (strcmp(name, STAT_FIND_PEER_REPLY) == 0)
 981     stats_ctx->stat_find_peer_reply = value;
 982   else if (strcmp(name, STAT_GET_REPLY) == 0)
 983     stats_ctx->stat_get_reply = value;
 984   else if (strcmp(name, STAT_FIND_PEER_ANSWER) == 0)
 985     stats_ctx->stat_find_peer_answer = value;
 986   else if (strcmp(name, STAT_GET_RESPONSE_START) == 0)
 987     stats_ctx->stat_get_response_start = value;
 988
 989   return GNUNET_OK;
 990 }
 991
 992 /**
 993  * Connect to statistics service for each peer and get the appropriate
 994  * dht statistics for safe keeping.
 995  */
 996 static void
 997 log_dht_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 998 {
 999   stats_map = GNUNET_CONTAINER_multihashmap_create(num_peers);
1000   fprintf(stderr, "Starting statistics logging\n");
1001   GNUNET_TESTING_get_statistics(pg, &stats_finished, &stats_handle, NULL);
1002 }
1003
1004
1005 /**
1006  * Connect to all peers in the peer group and iterate over their
1007  * connections.
1008  */
1009 static void
1010 capture_current_topology (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1011 {
1012   struct TopologyIteratorContext *topo_ctx = cls;
1013   dhtlog_handle->insert_topology(0);
1014   GNUNET_TESTING_get_topology (pg, &log_topology_cb, topo_ctx);
1015 }
1016
1017
1018 /**
1019  * Check if the get_handle is being used, if so stop the request.  Either
1020  * way, schedule the end_badly_cont function which actually shuts down the
1021  * test.
1022  */
1023 static void
1024 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1025 {
1026   GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failing test with error: `%s'!\n", (char *)cls);
1027
1028   struct TestPutContext *test_put = all_puts;
1029   struct TestGetContext *test_get = all_gets;
1030
1031   while (test_put != NULL)
1032     {
1033       if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
1034         GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
1035       if (test_put->dht_handle != NULL)
1036         GNUNET_DHT_disconnect(test_put->dht_handle);
1037       test_put = test_put->next;
1038     }
1039
1040   while (test_get != NULL)
1041     {
1042       if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
1043         GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
1044       if (test_get->get_handle != NULL)
1045         GNUNET_DHT_get_stop(test_get->get_handle);
1046       if (test_get->dht_handle != NULL)
1047         GNUNET_DHT_disconnect(test_get->dht_handle);
1048       test_get = test_get->next;
1049     }
1050
1051   GNUNET_TESTING_daemons_stop (pg, DEFAULT_TIMEOUT, &shutdown_callback, NULL);
1052
1053   if (dhtlog_handle != NULL)
1054     {
1055       fprintf(stderr, "Update trial endtime\n");
1056       dhtlog_handle->update_trial (gets_completed);
1057       GNUNET_DHTLOG_disconnect(dhtlog_handle);
1058       dhtlog_handle = NULL;
1059     }
1060
1061   if (hostkey_meter != NULL)
1062     free_meter(hostkey_meter);
1063   if (peer_start_meter != NULL)
1064     free_meter(peer_start_meter);
1065   if (peer_connect_meter != NULL)
1066     free_meter(peer_connect_meter);
1067   if (put_meter != NULL)
1068     free_meter(put_meter);
1069   if (get_meter != NULL)
1070     free_meter(get_meter);
1071
1072   ok = 1;
1073 }
1074
1075 /**
1076  * Forward declaration.
1077  */
1078 static void
1079 do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
1080
1081 /**
1082  * Forward declaration.
1083  */
1084 static void
1085 do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
1086
1087 /**
1088  * Iterator over hash map entries.
1089  *
1090  * @param cls closure
1091  * @param key current key code
1092  * @param value value in the hash map
1093  * @return GNUNET_YES if we should continue to
1094  *         iterate,
1095  *         GNUNET_NO if not.
1096  */
1097 static int remove_peer_count (void *cls,
1098                               const GNUNET_HashCode * key,
1099                               void *value)
1100 {
1101   struct FindPeerContext *find_peer_ctx = cls;
1102   struct PeerCount *peer_count = value;
1103   GNUNET_CONTAINER_heap_remove_node(find_peer_ctx->peer_min_heap, peer_count->heap_node);
1104   GNUNET_free(peer_count);
1105
1106   return GNUNET_YES;
1107 }
1108
1109 /**
1110  * Connect to all peers in the peer group and iterate over their
1111  * connections.
1112  */
1113 static void
1114 count_new_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1115 {
1116   struct FindPeerContext *find_peer_context = cls;
1117   find_peer_context->previous_peers = find_peer_context->current_peers;
1118   find_peer_context->current_peers = 0;
1119   GNUNET_TESTING_get_topology (pg, find_peer_context->count_peers_cb, find_peer_context);
1120 }
1121
1122 static void
1123 decrement_find_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1124 {
1125   struct TestFindPeer *test_find_peer = cls;
1126   GNUNET_assert(test_find_peer->find_peer_context->outstanding > 0);
1127   test_find_peer->find_peer_context->outstanding--;
1128   test_find_peer->find_peer_context->total--;
1129   if ((0 == test_find_peer->find_peer_context->total) &&
1130       (GNUNET_TIME_absolute_get_remaining(test_find_peer->find_peer_context->endtime).rel_value > 60))
1131   {
1132     GNUNET_SCHEDULER_add_now(&count_new_peers, test_find_peer->find_peer_context);
1133   }
1134   GNUNET_free(test_find_peer);
1135 }
1136
1137 /**
1138  * A find peer request has been sent to the server, now we will schedule a task
1139  * to wait the appropriate time to allow the request to go out and back.
1140  *
1141  * @param cls closure - a TestFindPeer struct
1142  * @param tc context the task is being called with
1143  */
1144 static void
1145 handle_find_peer_sent (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1146 {
1147   struct TestFindPeer *test_find_peer = cls;
1148
1149   GNUNET_DHT_disconnect(test_find_peer->dht_handle);
1150   GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_divide(find_peer_delay, 2), &decrement_find_peers, test_find_peer);
1151 }
1152
1153
1154 static void
1155 send_find_peer_request (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1156 {
1157   struct TestFindPeer *test_find_peer = cls;
1158
1159   if (test_find_peer->find_peer_context->outstanding > max_outstanding_find_peers)
1160   {
1161     GNUNET_SCHEDULER_add_delayed(find_peer_offset, &send_find_peer_request, test_find_peer);
1162     return;
1163   }
1164
1165   test_find_peer->find_peer_context->outstanding++;
1166   if (GNUNET_TIME_absolute_get_remaining(test_find_peer->find_peer_context->endtime).rel_value == 0)
1167   {
1168     GNUNET_SCHEDULER_add_now(&decrement_find_peers, test_find_peer);
1169     return;
1170   }
1171
1172   test_find_peer->dht_handle = GNUNET_DHT_connect(test_find_peer->daemon->cfg, 1);
1173   GNUNET_assert(test_find_peer->dht_handle != NULL);
1174   GNUNET_DHT_find_peers (test_find_peer->dht_handle,
1175                          &handle_find_peer_sent, test_find_peer);
1176 }
1177
1178
1179 /**
1180  * Add a connection to the find_peer_context given.  This may
1181  * be complete overkill, but allows us to choose the peers with
1182  * the least connections to initiate find peer requests from.
1183  */
1184 static void add_new_connection(struct FindPeerContext *find_peer_context,
1185                                const struct GNUNET_PeerIdentity *first,
1186                                const struct GNUNET_PeerIdentity *second)
1187 {
1188   struct PeerCount *first_count;
1189   struct PeerCount *second_count;
1190
1191   if (GNUNET_CONTAINER_multihashmap_contains(find_peer_context->peer_hash, &first->hashPubKey))
1192   {
1193     first_count = GNUNET_CONTAINER_multihashmap_get(find_peer_context->peer_hash, &first->hashPubKey);
1194     GNUNET_assert(first_count != NULL);
1195     first_count->count++;
1196     GNUNET_CONTAINER_heap_update_cost(find_peer_context->peer_min_heap, first_count->heap_node, first_count->count);
1197   }
1198   else
1199   {
1200     first_count = GNUNET_malloc(sizeof(struct PeerCount));
1201     first_count->count = 1;
1202     memcpy(&first_count->peer_id, first, sizeof(struct GNUNET_PeerIdentity));
1203     first_count->heap_node = GNUNET_CONTAINER_heap_insert(find_peer_context->peer_min_heap, first_count, first_count->count);
1204     GNUNET_CONTAINER_multihashmap_put(find_peer_context->peer_hash, &first->hashPubKey, first_count, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
1205   }
1206
1207   if (GNUNET_CONTAINER_multihashmap_contains(find_peer_context->peer_hash, &second->hashPubKey))
1208   {
1209     second_count = GNUNET_CONTAINER_multihashmap_get(find_peer_context->peer_hash, &second->hashPubKey);
1210     GNUNET_assert(second_count != NULL);
1211     second_count->count++;
1212     GNUNET_CONTAINER_heap_update_cost(find_peer_context->peer_min_heap, second_count->heap_node, second_count->count);
1213   }
1214   else
1215   {
1216     second_count = GNUNET_malloc(sizeof(struct PeerCount));
1217     second_count->count = 1;
1218     memcpy(&second_count->peer_id, second, sizeof(struct GNUNET_PeerIdentity));
1219     second_count->heap_node = GNUNET_CONTAINER_heap_insert(find_peer_context->peer_min_heap, second_count, second_count->count);
1220     GNUNET_CONTAINER_multihashmap_put(find_peer_context->peer_hash, &second->hashPubKey, second_count, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
1221   }
1222 }
1223
1224
1225 /**
1226  * Iterate over min heap of connections per peer.  For any
1227  * peer that has 0 connections, attempt to connect them to
1228  * some random peer.
1229  *
1230  * @param cls closure a struct FindPeerContext
1231  * @param node internal node of the heap
1232  * @param element value stored, a struct PeerCount
1233  * @param cost cost associated with the node
1234  * @return GNUNET_YES if we should continue to iterate,
1235  *         GNUNET_NO if not.
1236  */
1237 static int iterate_min_heap_peers (void *cls,
1238                                    struct GNUNET_CONTAINER_HeapNode *node,
1239                                    void *element,
1240                                    GNUNET_CONTAINER_HeapCostType cost)
1241 {
1242   struct FindPeerContext *find_peer_context = cls;
1243   struct PeerCount *peer_count = element;
1244   struct GNUNET_TESTING_Daemon *d1;
1245   struct GNUNET_TESTING_Daemon *d2;
1246   struct GNUNET_TIME_Relative timeout;
1247   if (cost == 0)
1248     {
1249       d1 = GNUNET_TESTING_daemon_get_by_id (pg, &peer_count->peer_id);
1250       GNUNET_assert(d1 != NULL);
1251       d2 = d1;
1252       while ((d2 == d1) || (GNUNET_YES != GNUNET_TESTING_daemon_running(d2)))
1253         {
1254           d2 = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers));
1255           GNUNET_assert(d2 != NULL);
1256         }
1257
1258       /** Just try to connect the peers, don't worry about callbacks, etc. **/
1259       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer %s has 0 connections.  Trying to connect to %s...\n", GNUNET_i2s(&peer_count->peer_id), d2->shortname);
1260       timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, DEFAULT_CONNECT_TIMEOUT);
1261       if (GNUNET_TIME_relative_to_absolute(timeout).abs_value > find_peer_context->endtime.abs_value)
1262         {
1263           timeout = GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime);
1264         }
1265       GNUNET_TESTING_daemons_connect(d1, d2, timeout, DEFAULT_RECONNECT_ATTEMPTS, NULL, NULL);
1266     }
1267   if (GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0)
1268     return GNUNET_YES;
1269   else
1270     return GNUNET_NO;
1271 }
1272
1273 /**
1274  * Forward declaration.
1275  */
1276 static void
1277 schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
1278
1279 /**
1280  * Callback for iterating over all the peer connections of a peer group.
1281  * Used after we have churned on some peers to find which ones have zero
1282  * connections so we can make them issue find peer requests.
1283  */
1284 static void
1285 count_peers_churn_cb (void *cls,
1286                       const struct GNUNET_PeerIdentity *first,
1287                       const struct GNUNET_PeerIdentity *second,
1288                       const char *emsg)
1289 {
1290   struct FindPeerContext *find_peer_context = cls;
1291   struct TopologyIteratorContext *topo_ctx;
1292   struct PeerCount *peer_count;
1293
1294   if ((first != NULL) && (second != NULL))
1295     {
1296       add_new_connection(find_peer_context, first, second);
1297       find_peer_context->current_peers++;
1298     }
1299   else
1300     {
1301       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer count finished (%u connections)\n",
1302                                             find_peer_context->current_peers);
1303       peer_count = GNUNET_CONTAINER_heap_peek(find_peer_context->peer_min_heap);
1304       GNUNET_assert(peer_count != NULL);
1305       /* WAIT. When peers are churned they will come back with their peers (at least in peerinfo), because the HOSTS file doesn't likely get removed. CRAP. */
1306       /* NO they won't, because we have disabled peerinfo writing to disk (remember?) so we WILL have to give them new connections */
1307       /* Best course of action: have DHT automatically try to add peers from peerinfo on startup. This way IF peerinfo writes to file
1308        * then some peers will end up connected.
1309        *
1310        * Also, find any peers that have zero connections here and set up a task to choose at random another peer in the network to
1311        * connect to.  Of course, if they are blacklisted from that peer they won't be able to connect, so we will have to keep trying
1312        * until they get a peer.
1313        */
1314       /* However, they won't automatically be connected to any of their previous peers... How can we handle that? */
1315       /* So now we have choices: do we want them to come back with all their connections?  Probably not, but it solves this mess. */
1316
1317       /* Second problem, which is still a problem, is that a FIND_PEER request won't work when a peer has no connections */
1318
1319       /**
1320        * Okay, so here's how this *should* work now.
1321        *
1322        * 1. We check the min heap for any peers that have 0 connections.
1323        *    a. If any are found, we iterate over the heap and just randomly
1324        *       choose another peer and ask testing to please connect the two.
1325        *       This takes care of the case that a peer just randomly joins the
1326        *       network.  However, if there are strict topology restrictions
1327        *       (imagine a ring) choosing randomly most likely won't help.
1328        *       We make sure the connection attempt doesn't take longer than
1329        *       the total timeout, but don't care too much about the result.
1330        *    b. After that, we still schedule the find peer requests (concurrently
1331        *       with the connect attempts most likely).  This handles the case
1332        *       that the DHT iterates over peerinfo and just needs to try to send
1333        *       a message to get connected.  This should handle the case that the
1334        *       topology is very strict.
1335        *
1336        * 2. If all peers have > 0 connections, we still send find peer requests
1337        *    as long as possible (until timeout is reached) to help out those
1338        *    peers that were newly churned and need more connections.  This is because
1339        *    once all new peers have established a single connection, they won't be
1340        *    well connected.
1341        *
1342        * 3. Once we reach the timeout, we can do no more.  We must schedule the
1343        *    next iteration of get requests regardless of connections that peers
1344        *    may or may not have.
1345        *
1346        * Caveat: it would be nice to get peers to take data offline with them and
1347        *         come back with it (or not) based on the testing framework.  The
1348        *         same goes for remembering previous connections, but putting either
1349        *         into the general testing churn options seems like overkill because
1350        *         these are very specialized cases.
1351        */
1352       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Out of %u peers, fewest connections is %d\n", GNUNET_CONTAINER_heap_get_size(find_peer_context->peer_min_heap), peer_count->count);
1353       if ((peer_count->count == 0) && (GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0))
1354         {
1355           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Found peer with no connections, will choose some peer(s) at random to connect to!\n");
1356           GNUNET_CONTAINER_heap_iterate (find_peer_context->peer_min_heap, &iterate_min_heap_peers, find_peer_context);
1357           GNUNET_SCHEDULER_add_now(&schedule_churn_find_peer_requests, find_peer_context);
1358         }
1359       else if ((GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0) && (find_peer_context->last_sent != 0))
1360         {
1361           GNUNET_SCHEDULER_add_now(&schedule_churn_find_peer_requests, find_peer_context);
1362         }
1363       else
1364         {
1365           GNUNET_CONTAINER_multihashmap_iterate(find_peer_context->peer_hash, &remove_peer_count, find_peer_context);
1366           GNUNET_CONTAINER_multihashmap_destroy(find_peer_context->peer_hash);
1367           GNUNET_CONTAINER_heap_destroy(find_peer_context->peer_min_heap);
1368           GNUNET_free(find_peer_context);
1369           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Churn round %u of %llu finished, scheduling next GET round.\n", current_churn_round, churn_rounds);
1370           if (dhtlog_handle != NULL)
1371             {
1372               topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
1373               topo_ctx->cont = &do_get;
1374               topo_ctx->cls = all_gets;
1375               topo_ctx->timeout = DEFAULT_GET_TIMEOUT;
1376               topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
1377               die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
1378                                                        &end_badly, "from do gets (count_peers_churn_cb)");
1379               GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
1380             }
1381           else
1382             {
1383               die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
1384                                                        &end_badly, "from do gets (count_peers_churn_cb)");
1385               GNUNET_SCHEDULER_add_now(&do_get, all_gets);
1386             }
1387         }
1388     }
1389 }
1390
1391 /**
1392  * Set up a single find peer request for each peer in the topology.  Do this
1393  * until the settle time is over, limited by the number of outstanding requests
1394  * and the time allowed for each one!
1395  */
1396 static void
1397 schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1398 {
1399   struct FindPeerContext *find_peer_ctx = cls;
1400   struct TestFindPeer *test_find_peer;
1401   struct PeerCount *peer_count;
1402   uint32_t i;
1403
1404   if (find_peer_ctx->previous_peers == 0) /* First time, go slowly */
1405     find_peer_ctx->total = 1;
1406   else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers < MIN_FIND_PEER_CUTOFF)
1407     find_peer_ctx->total = find_peer_ctx->total / 2;
1408   else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers > MAX_FIND_PEER_CUTOFF) /* Found LOTS of peers, still go slowly */
1409     find_peer_ctx->total = find_peer_ctx->last_sent - (find_peer_ctx->last_sent / 4);
1410   else
1411     find_peer_ctx->total = find_peer_ctx->last_sent * 4;
1412
1413   if (find_peer_ctx->total > max_outstanding_find_peers)
1414     find_peer_ctx->total = max_outstanding_find_peers;
1415
1416   find_peer_ctx->last_sent = find_peer_ctx->total;
1417   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending %u find peer messages (after churn)\n", find_peer_ctx->total);
1418
1419   if (find_peer_ctx->total > 0)
1420     find_peer_offset = GNUNET_TIME_relative_divide(find_peer_delay, find_peer_ctx->total);
1421   else
1422     {
1423       find_peer_ctx->previous_peers = find_peer_ctx->current_peers;
1424       find_peer_ctx->current_peers = 0;
1425       GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_ctx);
1426     }
1427
1428
1429   for (i = 0; i < find_peer_ctx->total; i++)
1430     {
1431       test_find_peer = GNUNET_malloc(sizeof(struct TestFindPeer));
1432       /* If we have sent requests, choose peers with a low number of connections to send requests from */
1433       peer_count = GNUNET_CONTAINER_heap_remove_root(find_peer_ctx->peer_min_heap);
1434       GNUNET_assert(peer_count != NULL);
1435       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending find peer request from peer with %u connections\n", peer_count->count);
1436       GNUNET_CONTAINER_multihashmap_remove(find_peer_ctx->peer_hash, &peer_count->peer_id.hashPubKey, peer_count);
1437       test_find_peer->daemon = GNUNET_TESTING_daemon_get_by_id(pg, &peer_count->peer_id);
1438       GNUNET_assert(test_find_peer->daemon != NULL);
1439       test_find_peer->find_peer_context = find_peer_ctx;
1440       GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer);
1441     }
1442
1443   if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap == NULL))
1444     {
1445       find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers);
1446       find_peer_ctx->peer_min_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
1447     }
1448   else
1449     {
1450       GNUNET_CONTAINER_multihashmap_iterate(find_peer_ctx->peer_hash, &remove_peer_count, find_peer_ctx);
1451       GNUNET_CONTAINER_multihashmap_destroy(find_peer_ctx->peer_hash);
1452       find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers);
1453     }
1454
1455   GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(find_peer_ctx->peer_hash));
1456   GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(find_peer_ctx->peer_min_heap));
1457 }
1458
1459 static void schedule_churn_get_topology (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1460 {
1461   struct FindPeerContext *find_peer_context = cls;
1462   GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_context);
1463 }
1464
1465 /**
1466  * Called when churning of the topology has finished.
1467  *
1468  * @param cls closure unused
1469  * @param emsg NULL on success, or a printable error on failure
1470  */
1471 static void churn_complete (void *cls, const char *emsg)
1472 {
1473   struct FindPeerContext *find_peer_context = cls;
1474   struct PeerCount *peer_count;
1475   unsigned int i;
1476   struct GNUNET_TESTING_Daemon *temp_daemon;
1477   struct TopologyIteratorContext *topo_ctx;
1478   struct GNUNET_TIME_Relative calc_timeout;
1479   int count_added;
1480
1481   if (emsg != NULL)
1482     {
1483       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Ending test, churning of peers failed with error `%s'", emsg);
1484       GNUNET_SCHEDULER_add_now(&end_badly, (void *)emsg);
1485       return;
1486     }
1487
1488   /**
1489    * If we switched any peers on, we have to somehow force connect the new peer to
1490    * SOME bootstrap peer in the network.  First schedule a task to find all peers
1491    * with no connections, then choose a random peer for each and connect them.
1492    */
1493   if (find_peer_context != NULL)
1494     {
1495       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "We have churned on some peers, so we must schedule find peer requests for them!\n");
1496       count_added = 0;
1497       for (i = 0; i < num_peers; i ++)
1498         {
1499           temp_daemon = GNUNET_TESTING_daemon_get(pg, i);
1500           if (GNUNET_YES == GNUNET_TESTING_daemon_running(temp_daemon))
1501             {
1502               peer_count = GNUNET_malloc (sizeof(struct PeerCount));
1503               memcpy(&peer_count->peer_id, &temp_daemon->id, sizeof(struct GNUNET_PeerIdentity));
1504               GNUNET_assert(peer_count->count == 0);
1505               peer_count->heap_node = GNUNET_CONTAINER_heap_insert(find_peer_context->peer_min_heap, peer_count, peer_count->count);
1506               GNUNET_CONTAINER_multihashmap_put(find_peer_context->peer_hash, &temp_daemon->id.hashPubKey, peer_count, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
1507               count_added++;
1508             }
1509         }
1510       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Added %d peers to heap, total size %d\n", count_added, GNUNET_CONTAINER_heap_get_size(find_peer_context->peer_min_heap));
1511       GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &schedule_churn_get_topology, find_peer_context);
1512       //GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_context);
1513     }
1514   else
1515     {
1516       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Only churned off peers, no find peer requests, scheduling more gets (after allowing time for peers to disconnect properly!)...\n");
1517       if (dhtlog_handle != NULL)
1518         {
1519           topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
1520           topo_ctx->cont = &do_get;
1521           topo_ctx->cls = all_gets;
1522           topo_ctx->timeout = DEFAULT_GET_TIMEOUT;
1523           topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
1524           calc_timeout = GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout);
1525           calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT);
1526           calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_PEER_DISCONNECT_TIMEOUT);
1527           die_task = GNUNET_SCHEDULER_add_delayed (calc_timeout,
1528                                                    &end_badly, "from do gets (churn_complete)");
1529           GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &capture_current_topology, topo_ctx);
1530         }
1531       else
1532         {
1533           calc_timeout = GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout);
1534           calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_PEER_DISCONNECT_TIMEOUT);
1535           die_task = GNUNET_SCHEDULER_add_delayed (calc_timeout,
1536                                                    &end_badly, "from do gets (churn_complete)");
1537           if (dhtlog_handle != NULL)
1538             dhtlog_handle->insert_round(DHT_ROUND_GET, rounds_finished);
1539           GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &do_get, all_gets);
1540         }
1541     }
1542 }
1543
1544 /**
1545  * Decide how many peers to turn on or off in this round, make sure the
1546  * numbers actually make sense, then do so.  This function sets in motion
1547  * churn, find peer requests for newly joined peers, and issuing get
1548  * requests once the new peers have done so.
1549  *
1550  * @param cls closure (unused)
1551  * @param cls task context (unused)
1552  */
1553 static void
1554 churn_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1555 {
1556   unsigned int count_running;
1557   unsigned int churn_up;
1558   unsigned int churn_down;
1559   struct GNUNET_TIME_Relative timeout;
1560   struct FindPeerContext *find_peer_context;
1561
1562   churn_up = churn_down = 0;
1563   count_running = GNUNET_TESTING_daemons_running(pg);
1564   if (count_running > churn_array[current_churn_round])
1565     churn_down = count_running - churn_array[current_churn_round];
1566   else if (count_running < churn_array[current_churn_round])
1567     churn_up = churn_array[current_churn_round] - count_running;
1568   else
1569     GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Not churning any peers, topology unchanged.\n");
1570
1571   if (churn_up > num_peers - count_running)
1572     {
1573       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Churn file specified %u peers (up); only have %u!", churn_array[current_churn_round], num_peers);
1574       churn_up = num_peers - count_running;
1575     }
1576   else if (churn_down > count_running)
1577     {
1578       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Churn file specified %u peers (down); only have %u!", churn_array[current_churn_round], count_running);
1579       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "This will leave NO peers running (mistake in churn configuration?)!");
1580       churn_down = count_running;
1581     }
1582   //timeout = GNUNET_TIME_relative_multiply(seconds_per_peer_start, churn_up > 0 ? churn_up : churn_down);
1583   //timeout = GNUNET_TIME_relative_multiply (seconds_per_peer_start, churn_up > 0 ? churn_up : churn_down);
1584   timeout = GNUNET_TIME_relative_multiply(DEFAULT_TIMEOUT, 2); /* FIXME: Lack of intelligent choice here */
1585   find_peer_context = NULL;
1586   if (churn_up > 0) /* Only need to do find peer requests if we turned new peers on */
1587     {
1588       find_peer_context = GNUNET_malloc(sizeof(struct FindPeerContext));
1589       find_peer_context->count_peers_cb = &count_peers_churn_cb;
1590       find_peer_context->previous_peers = 0;
1591       find_peer_context->current_peers = 0;
1592       find_peer_context->endtime = GNUNET_TIME_relative_to_absolute(timeout);
1593       find_peer_context->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers);
1594       find_peer_context->peer_min_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
1595     }
1596   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "churn_peers: want %u total, %u running, starting %u, stopping %u\n",
1597              churn_array[current_churn_round], count_running, churn_up, churn_down);
1598   GNUNET_TESTING_daemons_churn (pg, churn_down, churn_up, timeout, &churn_complete, find_peer_context);
1599   current_churn_round++;
1600 }
1601
1602 /**
1603  * Task to release DHT handle associated with GET request.
1604  */
1605 static void
1606 get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1607 {
1608   struct TestGetContext *test_get = cls;
1609   struct TopologyIteratorContext *topo_ctx;
1610
1611   /* The dht_handle may be null if this get was scheduled from a down peer */
1612   if (test_get->dht_handle != NULL)
1613     {
1614       GNUNET_DHT_disconnect(test_get->dht_handle);
1615       outstanding_gets--; /* GET is really finished */
1616       test_get->dht_handle = NULL;
1617     }
1618
1619   /* Reset the uid (which item to search for) and the daemon (which peer to search from) for later get request iterations */
1620   if (get_from_same == GNUNET_NO)
1621     {
1622       test_get->uid = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_puts);
1623       test_get->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers));
1624     }
1625
1626 #if VERBOSE > 1
1627   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%d gets succeeded, %d gets failed!\n", gets_completed, gets_failed);
1628 #endif
1629   update_meter(get_meter);
1630   if ((gets_completed + gets_failed == num_gets) && (outstanding_gets == 0))
1631     {
1632       fprintf(stderr, "Canceling die task (get_stop_finished) %llu gets completed, %llu gets failed\n", gets_completed, gets_failed);
1633       GNUNET_SCHEDULER_cancel(die_task);
1634       reset_meter(put_meter);
1635       reset_meter(get_meter);
1636       /**
1637        *  Handle all cases:
1638        *    1) Testing is completely finished, call the topology iteration dealy and die
1639        *    2) Testing is not finished, churn the network and do gets again (current_churn_round < churn_rounds)
1640        *    3) Testing is not finished, reschedule all the PUTS *and* GETS again (num_rounds > 1)
1641        */
1642       if (rounds_finished == total_rounds - 1) /* Everything is finished, end testing */
1643         {
1644           if (dhtlog_handle != NULL)
1645             {
1646               topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
1647               topo_ctx->cont = &log_dht_statistics;
1648               topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
1649               GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
1650             }
1651           else
1652             GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
1653         }
1654       else if (current_churn_round < churns_per_round * (rounds_finished + 1)) /* Do next round of churn */
1655         {
1656           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Current churn round %u, real round %u, scheduling next round of churn.\n", current_churn_round, rounds_finished + 1);
1657           gets_completed = 0;
1658           gets_failed = 0;
1659
1660           if (dhtlog_handle != NULL)
1661             dhtlog_handle->insert_round(DHT_ROUND_CHURN, rounds_finished);
1662
1663           GNUNET_SCHEDULER_add_now(&churn_peers, NULL);
1664         }
1665       else if (rounds_finished < total_rounds - 1) /* Start a new complete round */
1666         {
1667           rounds_finished++;
1668           gets_completed = 0;
1669           gets_failed = 0;
1670           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Round %u of %llu finished, scheduling next round.\n", rounds_finished, total_rounds);
1671
1672           /** We reset the peer daemon for puts and gets on each disconnect, so all we need to do is start another round! */
1673           if (GNUNET_YES == in_dht_replication) /* Replication done in DHT, don't redo puts! */
1674             {
1675               if (dhtlog_handle != NULL)
1676                 dhtlog_handle->insert_round(DHT_ROUND_GET, rounds_finished);
1677
1678               die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
1679                                                        &end_badly, "from do gets (next round)");
1680               GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_get, all_gets);
1681             }
1682           else
1683             {
1684               if (dhtlog_handle != NULL)
1685                 dhtlog_handle->insert_round(DHT_ROUND_NORMAL, rounds_finished);
1686               die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2)),
1687                                                        &end_badly, "from do puts");
1688               GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_put, all_puts);
1689             }
1690         }
1691     }
1692 }
1693
1694 /**
1695  * Task to release get handle.
1696  */
1697 static void
1698 get_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1699 {
1700   struct TestGetContext *test_get = cls;
1701
1702   if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT)
1703     gets_failed++;
1704   GNUNET_assert(test_get->get_handle != NULL);
1705   GNUNET_DHT_get_stop(test_get->get_handle);
1706   test_get->get_handle = NULL;
1707   test_get->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
1708   GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get);
1709 }
1710
1711 /**
1712  * Iterator called if the GET request initiated returns a response.
1713  *
1714  * @param cls closure
1715  * @param exp when will this value expire
1716  * @param key key of the result
1717  * @param get_path NULL-terminated array of pointers
1718  *                 to the peers on reverse GET path (or NULL if not recorded)
1719  * @param put_path NULL-terminated array of pointers
1720  *                 to the peers on the PUT path (or NULL if not recorded)
1721  * @param type type of the result
1722  * @param size number of bytes in data
1723  * @param data pointer to the result data
1724  */
1725 static void
1726 get_result_iterator (void *cls,
1727                      struct GNUNET_TIME_Absolute exp,
1728                      const GNUNET_HashCode * key,
1729                      const struct GNUNET_PeerIdentity * const *get_path,
1730                      const struct GNUNET_PeerIdentity * const *put_path,
1731                      enum GNUNET_BLOCK_Type type,
1732                      size_t size,
1733                      const void *data)
1734 {
1735   struct TestGetContext *test_get = cls;
1736
1737   if (test_get->succeeded == GNUNET_YES)
1738     return; /* Get has already been successful, probably ending now */
1739
1740   if (0 != memcmp(&known_keys[test_get->uid], key, sizeof (GNUNET_HashCode))) /* || (0 != memcmp(original_data, data, sizeof(original_data))))*/
1741     {
1742       gets_completed++;
1743       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Key or data is not the same as was inserted!\n");
1744     }
1745   else
1746     {
1747       gets_completed++;
1748       test_get->succeeded = GNUNET_YES;
1749     }
1750 #if VERBOSE > 1
1751   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
1752 #endif
1753   GNUNET_SCHEDULER_cancel(test_get->disconnect_task);
1754   GNUNET_SCHEDULER_add_continuation(&get_stop_task, test_get, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
1755 }
1756
1757
1758
1759 /**
1760  * Set up some data, and call API PUT function
1761  */
1762 static void
1763 do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1764 {
1765   struct TestGetContext *test_get = cls;
1766
1767   if (num_gets == 0)
1768     {
1769       GNUNET_SCHEDULER_cancel(die_task);
1770       GNUNET_SCHEDULER_add_now(&finish_testing, NULL);
1771     }
1772
1773   if (test_get == NULL)
1774     return; /* End of the list */
1775
1776   /* Set this here in case we are re-running gets */
1777   test_get->succeeded = GNUNET_NO;
1778
1779   if (GNUNET_YES != GNUNET_TESTING_daemon_running(test_get->daemon)) /* If the peer has been churned off, don't try issuing request from it! */
1780     {
1781       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer we should issue get request from is down, skipping.\n");
1782       gets_failed++;
1783       GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get);
1784       GNUNET_SCHEDULER_add_now (&do_get, test_get->next);
1785       return;
1786     }
1787
1788   /* Check if more gets are outstanding than should be */
1789   if (outstanding_gets > max_outstanding_gets)
1790     {
1791       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_get, test_get);
1792       return;
1793     }
1794
1795   /* Connect to the first peer's DHT */
1796   test_get->dht_handle = GNUNET_DHT_connect(test_get->daemon->cfg, 10);
1797   GNUNET_assert(test_get->dht_handle != NULL);
1798   outstanding_gets++;
1799
1800   /* Insert the data at the first peer */
1801   test_get->get_handle = GNUNET_DHT_get_start(test_get->dht_handle,
1802                                               get_delay,
1803                                               GNUNET_BLOCK_TYPE_TEST,
1804                                               &known_keys[test_get->uid],
1805                                               get_replication,
1806                                               GNUNET_DHT_RO_NONE,
1807                                               NULL, 0,
1808                                               NULL, 0,
1809                                               &get_result_iterator,
1810                                               test_get);
1811
1812 #if VERBOSE > 1
1813   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting get for uid %u from peer %s\n",
1814              test_get->uid,
1815              test_get->daemon->shortname);
1816 #endif
1817   test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed(get_timeout, &get_stop_task, test_get);
1818
1819   /* Schedule the next request in the linked list of get requests */
1820   GNUNET_SCHEDULER_add_now (&do_get, test_get->next);
1821 }
1822
1823 /**
1824  * Called when the PUT request has been transmitted to the DHT service.
1825  * Schedule the GET request for some time in the future.
1826  */
1827 static void
1828 put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1829 {
1830   struct TestPutContext *test_put = cls;
1831   struct TopologyIteratorContext *topo_ctx;
1832   outstanding_puts--;
1833   puts_completed++;
1834
1835   if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT)
1836     fprintf(stderr, "PUT Request failed!\n");
1837
1838   /* Reset the daemon (which peer to insert at) for later put request iterations */
1839   if (replicate_same == GNUNET_NO)
1840     test_put->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers));
1841
1842   GNUNET_SCHEDULER_cancel(test_put->disconnect_task);
1843   test_put->disconnect_task = GNUNET_SCHEDULER_add_now(&put_disconnect_task, test_put);
1844   if (GNUNET_YES == update_meter(put_meter))
1845     {
1846       GNUNET_assert(outstanding_puts == 0);
1847       GNUNET_SCHEDULER_cancel (die_task);
1848       if (dhtlog_handle != NULL)
1849         {
1850           topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
1851           topo_ctx->cont = &do_get;
1852           topo_ctx->cls = all_gets;
1853           topo_ctx->timeout = DEFAULT_GET_TIMEOUT;
1854           topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
1855           die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT),
1856                                                    &end_badly, "from do gets (put finished)");
1857           GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
1858         }
1859       else
1860         {
1861           fprintf(stderr, "Scheduling die task (put finished)\n");
1862           die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout),
1863                                                    &end_badly, "from do gets (put finished)");
1864           GNUNET_SCHEDULER_add_delayed(DEFAULT_GET_TIMEOUT, &do_get, all_gets);
1865         }
1866       return;
1867     }
1868 }
1869
1870 /**
1871  * Set up some data, and call API PUT function
1872  */
1873 static void
1874 do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
1875 {
1876   struct TestPutContext *test_put = cls;
1877   char data[test_data_size]; /* Made up data to store */
1878   uint32_t rand;
1879   int i;
1880
1881   if (test_put == NULL)
1882     return; /* End of list */
1883
1884   if (GNUNET_YES != GNUNET_TESTING_daemon_running(test_put->daemon)) /* If the peer has been churned off, don't try issuing request from it! */
1885     {
1886       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer we should issue put request at is down, skipping.\n");
1887       update_meter(put_meter);
1888       GNUNET_SCHEDULER_add_now (&do_put, test_put->next);
1889       return;
1890     }
1891
1892   for (i = 0; i < sizeof(data); i++)
1893     {
1894       memset(&data[i], GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX), 1);
1895     }
1896
1897   if (outstanding_puts > max_outstanding_puts)
1898     {
1899       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_put, test_put);
1900       return;
1901     }
1902
1903 #if VERBOSE > 1
1904     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting put for uid %u from peer %s\n",
1905                 test_put->uid,
1906                 test_put->daemon->shortname);
1907 #endif
1908   test_put->dht_handle = GNUNET_DHT_connect(test_put->daemon->cfg, 10);
1909
1910   GNUNET_assert(test_put->dht_handle != NULL);
1911   outstanding_puts++;
1912   GNUNET_DHT_put(test_put->dht_handle,
1913                  &known_keys[test_put->uid],
1914                  put_replication,
1915                  GNUNET_DHT_RO_NONE,
1916                  GNUNET_BLOCK_TYPE_TEST,
1917                  sizeof(data), data,
1918                  GNUNET_TIME_UNIT_FOREVER_ABS,
1919                  put_delay,
1920                  &put_finished, test_put);
1921   test_put->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_get_forever(), &put_disconnect_task, test_put);
1922   rand = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 2);
1923   GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, rand), &do_put, test_put->next);
1924 }
1925
1926 static void
1927 schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
1928
1929 /**
1930  * Given a number of total peers and a bucket size, estimate the number of
1931  * connections in a perfect kademlia topology.
1932  */
1933 static unsigned int connection_estimate(unsigned int peer_count, unsigned int bucket_size)
1934 {
1935   unsigned int i;
1936   unsigned int filled;
1937   i = num_peers;
1938
1939   filled = 0;
1940   while (i >= bucket_size)
1941     {
1942       filled++;
1943       i = i/2;
1944     }
1945   filled++; /* Add one filled bucket to account for one "half full" and some miscellaneous */
1946   return filled * bucket_size * peer_count;
1947
1948 }
1949
1950
1951 /**
1952  * Callback for iterating over all the peer connections of a peer group.
1953  */
1954 static void
1955 count_peers_cb (void *cls,
1956                 const struct GNUNET_PeerIdentity *first,
1957                 const struct GNUNET_PeerIdentity *second,
1958                 const char *emsg)
1959 {
1960   struct FindPeerContext *find_peer_context = cls;
1961   if ((first != NULL) && (second != NULL))
1962     {
1963       add_new_connection(find_peer_context, first, second);
1964       find_peer_context->current_peers++;
1965     }
1966   else
1967     {
1968       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer count finished (%u connections), %u new peers, connection estimate %u (double %u)\n",
1969                                             find_peer_context->current_peers,
1970                                             find_peer_context->current_peers - find_peer_context->previous_peers,
1971                                             connection_estimate(num_peers, DEFAULT_BUCKET_SIZE),
1972                                             2 * connection_estimate(num_peers, DEFAULT_BUCKET_SIZE));
1973
1974       if ((find_peer_context->last_sent < 8) ||
1975           ((find_peer_context->current_peers - find_peer_context->previous_peers > FIND_PEER_THRESHOLD) &&
1976           (find_peer_context->current_peers < 2 * connection_estimate(num_peers, DEFAULT_BUCKET_SIZE)) &&
1977           (GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0)))
1978         {
1979           GNUNET_SCHEDULER_add_now(&schedule_find_peer_requests, find_peer_context);
1980         }
1981       else
1982         {
1983           GNUNET_CONTAINER_multihashmap_iterate(find_peer_context->peer_hash, &remove_peer_count, find_peer_context);
1984           GNUNET_CONTAINER_multihashmap_destroy(find_peer_context->peer_hash);
1985           GNUNET_CONTAINER_heap_destroy(find_peer_context->peer_min_heap);
1986           GNUNET_free(find_peer_context);
1987           fprintf(stderr, "Not sending any more find peer requests.\n");
1988         }
1989     }
1990 }
1991
1992
1993 /**
1994  * Set up a single find peer request for each peer in the topology.  Do this
1995  * until the settle time is over, limited by the number of outstanding requests
1996  * and the time allowed for each one!
1997  */
1998 static void
1999 schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2000 {
2001   struct FindPeerContext *find_peer_ctx = cls;
2002   struct TestFindPeer *test_find_peer;
2003   struct PeerCount *peer_count;
2004   uint32_t i;
2005   uint32_t random;
2006
2007   if (find_peer_ctx->previous_peers == 0) /* First time, go slowly */
2008     find_peer_ctx->total = 1;
2009   else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers > MAX_FIND_PEER_CUTOFF) /* Found LOTS of peers, still go slowly */
2010     find_peer_ctx->total = find_peer_ctx->last_sent - (find_peer_ctx->last_sent / 8);
2011   else
2012     find_peer_ctx->total = find_peer_ctx->last_sent * 2;
2013
2014   if (find_peer_ctx->total > max_outstanding_find_peers)
2015     find_peer_ctx->total = max_outstanding_find_peers;
2016
2017   find_peer_ctx->last_sent = find_peer_ctx->total;
2018   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending %u find peer messages (goal at least %u connections)\n", find_peer_ctx->total, connection_estimate(num_peers, DEFAULT_BUCKET_SIZE));
2019
2020   find_peer_offset = GNUNET_TIME_relative_divide(find_peer_delay, find_peer_ctx->total);
2021   for (i = 0; i < find_peer_ctx->total; i++)
2022     {
2023       test_find_peer = GNUNET_malloc(sizeof(struct TestFindPeer));
2024       if (find_peer_ctx->previous_peers == 0) /* If we haven't sent any requests, yet choose random peers */
2025         {
2026           /**
2027            * Attempt to spread find peer requests across even sections of the peer address
2028            * space.  Choose basically 1 peer in every num_peers / max_outstanding_requests
2029            * each time, then offset it by a randomish value.
2030            *
2031            * For instance, if num_peers is 100 and max_outstanding is 10, first chosen peer
2032            * will be between 0 - 10, second between 10 - 20, etc.
2033            */
2034           random = (num_peers / find_peer_ctx->total) * i;
2035           random = random + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, (num_peers / find_peer_ctx->total));
2036           if (random >= num_peers)
2037             {
2038               random = random - num_peers;
2039             }
2040 #if REAL_RANDOM
2041           random = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
2042 #endif
2043           test_find_peer->daemon = GNUNET_TESTING_daemon_get(pg, random);
2044         }
2045       else /* If we have sent requests, choose peers with a low number of connections to send requests from */
2046         {
2047           peer_count = GNUNET_CONTAINER_heap_remove_root(find_peer_ctx->peer_min_heap);
2048           GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove(find_peer_ctx->peer_hash, &peer_count->peer_id.hashPubKey, peer_count));
2049           test_find_peer->daemon = GNUNET_TESTING_daemon_get_by_id(pg, &peer_count->peer_id);
2050           GNUNET_assert(test_find_peer->daemon != NULL);
2051         }
2052
2053       test_find_peer->find_peer_context = find_peer_ctx;
2054       GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer);
2055     }
2056
2057   if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap == NULL))
2058     {
2059       find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers);
2060       find_peer_ctx->peer_min_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
2061     }
2062   else
2063     {
2064       GNUNET_CONTAINER_multihashmap_iterate(find_peer_ctx->peer_hash, &remove_peer_count, find_peer_ctx);
2065       GNUNET_CONTAINER_multihashmap_destroy(find_peer_ctx->peer_hash);
2066       find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers);
2067     }
2068
2069   GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(find_peer_ctx->peer_hash));
2070   GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(find_peer_ctx->peer_min_heap));
2071
2072 }
2073
2074 /**
2075  * Set up some all of the put and get operations we want
2076  * to do.  Allocate data structure for each, add to list,
2077  * then call actual insert functions.
2078  */
2079 static void
2080 setup_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2081 {
2082   int i;
2083   uint32_t temp_daemon;
2084   struct TestPutContext *test_put;
2085   struct TestGetContext *test_get;
2086 #if REMEMBER
2087   int remember[num_puts][num_peers];
2088   memset(&remember, 0, sizeof(int) * num_puts * num_peers);
2089 #endif
2090   known_keys = GNUNET_malloc(sizeof(GNUNET_HashCode) * num_puts);
2091   for (i = 0; i < num_puts; i++)
2092     {
2093       test_put = GNUNET_malloc(sizeof(struct TestPutContext));
2094       test_put->uid = i;
2095       GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &known_keys[i]);
2096       temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
2097       test_put->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
2098       test_put->next = all_puts;
2099       all_puts = test_put;
2100     }
2101
2102   for (i = 0; i < num_gets; i++)
2103     {
2104       test_get = GNUNET_malloc(sizeof(struct TestGetContext));
2105       test_get->uid = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_puts);
2106 #if REMEMBER
2107       while (remember[test_get->uid][temp_daemon] == 1)
2108         temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
2109       remember[test_get->uid][temp_daemon] = 1;
2110 #endif
2111       test_get->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers));
2112       test_get->next = all_gets;
2113       all_gets = test_get;
2114     }
2115
2116   /*GNUNET_SCHEDULER_cancel (die_task);*/
2117   die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2),
2118                                            &end_badly, "from do puts");
2119   GNUNET_SCHEDULER_add_now (&do_put, all_puts);
2120
2121 }
2122
2123 /**
2124  * Set up some all of the put and get operations we want
2125  * to do.  Allocate data structure for each, add to list,
2126  * then call actual insert functions.
2127  */
2128 static void
2129 continue_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2130 {
2131   int i;
2132   int max;
2133   struct TopologyIteratorContext *topo_ctx;
2134   struct FindPeerContext *find_peer_context;
2135   if (dhtlog_handle != NULL)
2136     {
2137       if (settle_time >= 180 * 2)
2138         max = (settle_time / 180) - 2;
2139       else
2140         max = 1;
2141       for (i = 1; i < max; i++)
2142         {
2143           topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
2144           topo_ctx->current_iteration = i;
2145           topo_ctx->total_iterations = max;
2146           topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
2147           //fprintf(stderr, "scheduled topology iteration in %d minutes\n", i);
2148           GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, i * 3), &capture_current_topology, topo_ctx);
2149         }
2150       topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
2151       topo_ctx->cont = &setup_puts_and_gets;
2152       topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
2153       GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 90)), &capture_current_topology, topo_ctx);
2154     }
2155   else
2156     GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 90)), &setup_puts_and_gets, NULL);
2157
2158   if (dhtlog_handle != NULL)
2159     dhtlog_handle->insert_round(DHT_ROUND_NORMAL, rounds_finished);
2160
2161   if (GNUNET_YES == do_find_peer)
2162     {
2163       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling find peer requests during \"settle\" time.\n");
2164       find_peer_context = GNUNET_malloc(sizeof(struct FindPeerContext));
2165       find_peer_context->count_peers_cb = &count_peers_cb;
2166       find_peer_context->endtime = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time));
2167       GNUNET_SCHEDULER_add_now(&schedule_find_peer_requests, find_peer_context);
2168     }
2169   else
2170     {
2171       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Assuming automatic DHT find peer requests.\n");
2172     }
2173 }
2174
2175 /**
2176  * Task to release DHT handles
2177  */
2178 static void
2179 malicious_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2180 {
2181   struct MaliciousContext *ctx = cls;
2182   outstanding_malicious--;
2183   malicious_completed++;
2184   ctx->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
2185   GNUNET_DHT_disconnect(ctx->dht_handle);
2186   ctx->dht_handle = NULL;
2187   GNUNET_free(ctx);
2188
2189   if (malicious_completed == malicious_getters + malicious_putters + malicious_droppers)
2190     {
2191       GNUNET_SCHEDULER_cancel(die_task);
2192       fprintf(stderr, "Finished setting all malicious peers up, calling continuation!\n");
2193       if (dhtlog_handle != NULL)
2194         GNUNET_SCHEDULER_add_now (&continue_puts_and_gets, NULL);
2195       else
2196         GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time),
2197                                     &continue_puts_and_gets, NULL);
2198     }
2199
2200 }
2201
2202 /**
2203  * Task to release DHT handles
2204  */
2205 static void
2206 malicious_done_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2207 {
2208   struct MaliciousContext *ctx = cls;
2209   GNUNET_SCHEDULER_cancel(ctx->disconnect_task);
2210   GNUNET_SCHEDULER_add_now(&malicious_disconnect_task, ctx);
2211 }
2212
2213 /**
2214  * Set up some data, and call API PUT function
2215  */
2216 static void
2217 set_malicious (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2218 {
2219   struct MaliciousContext *ctx = cls;
2220
2221   if (outstanding_malicious > DEFAULT_MAX_OUTSTANDING_GETS)
2222     {
2223       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &set_malicious, ctx);
2224       return;
2225     }
2226
2227   if (ctx->dht_handle == NULL)
2228     {
2229       ctx->dht_handle = GNUNET_DHT_connect(ctx->daemon->cfg, 1);
2230       outstanding_malicious++;
2231     }
2232
2233   GNUNET_assert(ctx->dht_handle != NULL);
2234
2235
2236 #if VERBOSE > 1
2237     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting peer %s malicious type %d\n",
2238                 ctx->daemon->shortname, ctx->malicious_type);
2239 #endif
2240
2241   switch (ctx->malicious_type)
2242   {
2243   case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET:
2244     GNUNET_DHT_set_malicious_getter(ctx->dht_handle, malicious_get_frequency);
2245     GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx);
2246     break;
2247   case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT:
2248     GNUNET_DHT_set_malicious_putter(ctx->dht_handle, malicious_put_frequency);
2249     GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx);
2250     break;
2251   case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP:
2252     GNUNET_DHT_set_malicious_dropper(ctx->dht_handle);
2253     GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx);
2254     break;
2255   default:
2256     break;
2257   }
2258
2259   ctx->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_FOREVER_REL,
2260                                                       &malicious_disconnect_task, ctx);
2261 }
2262
2263 /**
2264  * Select randomly from set of known peers,
2265  * set the desired number of peers to the
2266  * proper malicious types.
2267  */
2268 static void
2269 setup_malicious_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
2270 {
2271   struct MaliciousContext *ctx;
2272   int i;
2273   uint32_t temp_daemon;
2274
2275   for (i = 0; i < malicious_getters; i++)
2276     {
2277       ctx = GNUNET_malloc(sizeof(struct MaliciousContext));
2278       temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
2279       ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
2280       ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET;
2281       GNUNET_SCHEDULER_add_now (&set_malicious, ctx);
2282
2283     }
2284
2285   for (i = 0; i < malicious_putters; i++)
2286     {
2287       ctx = GNUNET_malloc(sizeof(struct MaliciousContext));
2288       temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
2289       ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
2290       ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT;
2291       GNUNET_SCHEDULER_add_now (&set_malicious, ctx);
2292
2293     }
2294
2295   for (i = 0; i < malicious_droppers; i++)
2296     {
2297       ctx = GNUNET_malloc(sizeof(struct MaliciousContext));
2298       temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers);
2299       ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon);
2300       ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP;
2301       GNUNET_SCHEDULER_add_now (&set_malicious, ctx);
2302     }
2303
2304   /**
2305    * If we have any malicious peers to set up,
2306    * the malicious callback should call continue_gets_and_puts
2307    */
2308   if (malicious_getters + malicious_putters + malicious_droppers > 0)
2309     {
2310       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Giving malicious set tasks some time before starting testing!\n");
2311       die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (malicious_getters + malicious_putters + malicious_droppers) * 2),
2312                                                &end_badly, "from set malicious");
2313     }
2314   else /* Otherwise, continue testing */
2315     {
2316       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Scheduling continue_puts_and_gets now!\n");
2317       GNUNET_SCHEDULER_add_now (&continue_puts_and_gets, NULL);
2318     }
2319 }
2320
2321 /**
2322  * This function is called whenever a connection attempt is finished between two of
2323  * the started peers (started with GNUNET_TESTING_daemons_start).  The total
2324  * number of times this function is called should equal the number returned
2325  * from the GNUNET_TESTING_connect_topology call.
2326  *
2327  * The emsg variable is NULL on success (peers connected), and non-NULL on
2328  * failure (peers failed to connect).
2329  */
2330 static void
2331 topology_callback (void *cls,
2332                    const struct GNUNET_PeerIdentity *first,
2333                    const struct GNUNET_PeerIdentity *second,
2334                    uint32_t distance,
2335                    const struct GNUNET_CONFIGURATION_Handle *first_cfg,
2336                    const struct GNUNET_CONFIGURATION_Handle *second_cfg,
2337                    struct GNUNET_TESTING_Daemon *first_daemon,
2338                    struct GNUNET_TESTING_Daemon *second_daemon,
2339                    const char *emsg)
2340 {
2341   struct TopologyIteratorContext *topo_ctx;
2342   if (emsg == NULL)
2343     {
2344       total_connections++;
2345 #if VERBOSE > 1
2346       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n",
2347                  first_daemon->shortname,
2348                  second_daemon->shortname,
2349                  distance);
2350 #endif
2351     }
2352   else
2353     {
2354       failed_connections++;
2355       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to connect peer %s to peer %s with error :\n%s\n",
2356                   first_daemon->shortname,
2357                   second_daemon->shortname, emsg);
2358 #if VERBOSE
2359       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n",
2360                   first_daemon->shortname,
2361                   second_daemon->shortname, emsg);
2362 #endif
2363     }
2364
2365   GNUNET_assert(peer_connect_meter != NULL);
2366   if (GNUNET_YES == update_meter(peer_connect_meter))
2367     {
2368 #if VERBOSE
2369       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2370                   "Created %d total connections, which is our target number!  Starting next phase of testing.\n",
2371                   total_connections);
2372 #endif
2373       if (failed_connections > 0)
2374         GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "While connecting, had %u failed connections.\n", failed_connections);
2375       if (dhtlog_handle != NULL)
2376         {
2377           dhtlog_handle->update_connections (total_connections);
2378           dhtlog_handle->insert_topology(expected_connections);
2379         }
2380
2381       GNUNET_SCHEDULER_cancel (die_task);
2382       /*die_task = GNUNET_SCHEDULER_add_delayed (DEFAULT_TIMEOUT,
2383                                                &end_badly, "from setup puts/gets");*/
2384       if ((dhtlog_handle != NULL) && (settle_time > 0))
2385         {
2386           topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext));
2387           topo_ctx->cont = &setup_malicious_peers;
2388           topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers);
2389           //topo_ctx->cont = &continue_puts_and_gets;
2390           GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx);
2391         }
2392       else
2393         {
2394           GNUNET_SCHEDULER_add_now(&setup_malicious_peers, NULL);
2395           /*GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time),
2396                                         &continue_puts_and_gets, NULL);*/
2397         }
2398     }
2399   else if (total_connections + failed_connections == expected_connections)
2400     {
2401       GNUNET_SCHEDULER_cancel (die_task);
2402       die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
2403     }
2404 }
2405
2406 static void
2407 peers_started_callback (void *cls,
2408        const struct GNUNET_PeerIdentity *id,
2409        const struct GNUNET_CONFIGURATION_Handle *cfg,
2410        struct GNUNET_TESTING_Daemon *d, const char *emsg)
2411 {
2412   if (emsg != NULL)
2413     {
2414       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to start daemon with error: `%s'\n",
2415                   emsg);
2416       return;
2417     }
2418   GNUNET_assert (id != NULL);
2419
2420 #if VERBOSE > 1
2421   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n",
2422               (num_peers - peers_left) + 1, num_peers);
2423 #endif
2424
2425   peers_left--;
2426
2427   if (GNUNET_YES == update_meter(peer_start_meter))
2428     {
2429 #if VERBOSE
2430       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2431                   "All %d daemons started, now connecting peers!\n",
2432                   num_peers);
2433 #endif
2434       GNUNET_SCHEDULER_cancel (die_task);
2435
2436       expected_connections = UINT_MAX;
2437       if ((pg != NULL) && (peers_left == 0))
2438         {
2439           expected_connections = GNUNET_TESTING_connect_topology (pg, connect_topology, connect_topology_option, connect_topology_option_modifier, NULL, NULL);
2440
2441           peer_connect_meter = create_meter(expected_connections, "Peer connection ", GNUNET_YES);
2442           fprintf(stderr, "Have %d expected connections\n", expected_connections);
2443         }
2444
2445       if (expected_connections == GNUNET_SYSERR)
2446         {
2447           die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
2448         }
2449
2450       die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, DEFAULT_CONNECT_TIMEOUT * expected_connections),
2451                                                &end_badly, "from connect topology (timeout)");
2452
2453       ok = 0;
2454     }
2455 }
2456
2457 static void
2458 create_topology ()
2459 {
2460   peers_left = num_peers; /* Reset counter */
2461   if (GNUNET_TESTING_create_topology (pg, topology, blacklist_topology, blacklist_transports) != GNUNET_SYSERR)
2462     {
2463 #if VERBOSE
2464       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2465                   "Topology set up, now starting peers!\n");
2466 #endif
2467       GNUNET_TESTING_daemons_continue_startup(pg);
2468     }
2469   else
2470     {
2471       GNUNET_SCHEDULER_cancel (die_task);
2472       die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");
2473     }
2474   GNUNET_free_non_null(blacklist_transports);
2475   GNUNET_SCHEDULER_cancel (die_task);
2476   die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
2477                                            &end_badly, "from continue startup (timeout)");
2478 }
2479
2480 /**
2481  * Callback indicating that the hostkey was created for a peer.
2482  *
2483  * @param cls NULL
2484  * @param id the peer identity
2485  * @param d the daemon handle (pretty useless at this point, remove?)
2486  * @param emsg non-null on failure
2487  */
2488 static void
2489 hostkey_callback (void *cls,
2490                   const struct GNUNET_PeerIdentity *id,
2491                   struct GNUNET_TESTING_Daemon *d,
2492                   const char *emsg)
2493 {
2494   if (emsg != NULL)
2495     {
2496       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Hostkey callback received error: %s\n", emsg);
2497     }
2498
2499 #if VERBOSE > 1
2500     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2501                 "Hostkey (%d/%d) created for peer `%s'\n",
2502                 num_peers - peers_left, num_peers, GNUNET_i2s(id));
2503 #endif
2504
2505     peers_left--;
2506     if (GNUNET_YES == update_meter(hostkey_meter))
2507       {
2508 #if VERBOSE
2509         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2510                     "All %d hostkeys created, now creating topology!\n",
2511                     num_peers);
2512 #endif
2513         GNUNET_SCHEDULER_cancel (die_task);
2514         /* Set up task in case topology creation doesn't finish
2515          * within a reasonable amount of time */
2516         die_task = GNUNET_SCHEDULER_add_delayed (DEFAULT_TOPOLOGY_TIMEOUT,
2517                                                  &end_badly, "from create_topology");
2518         GNUNET_SCHEDULER_add_now(&create_topology, NULL);
2519         ok = 0;
2520       }
2521 }
2522
2523
2524 static void
2525 run (void *cls,
2526      char *const *args,
2527      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
2528 {
2529   struct stat frstat;
2530   struct GNUNET_DHTLOG_TrialInfo trial_info;
2531   struct GNUNET_TESTING_Host *hosts;
2532   struct GNUNET_TESTING_Host *temphost;
2533   struct GNUNET_TESTING_Host *tempnext;
2534   char *topology_str;
2535   char *connect_topology_str;
2536   char *blacklist_topology_str;
2537   char *connect_topology_option_str;
2538   char *connect_topology_option_modifier_string;
2539   char *trialmessage;
2540   char *topology_percentage_str;
2541   float topology_percentage;
2542   char *topology_probability_str;
2543   char *hostfile;
2544   float topology_probability;
2545   unsigned long long temp_config_number;
2546   unsigned long long trial_to_run;
2547   int stop_closest;
2548   int stop_found;
2549   int strict_kademlia;
2550   char *buf;
2551   char *data;
2552   char *churn_data;
2553   char *churn_filename;
2554   int count;
2555   int ret;
2556   int line_number;
2557
2558
2559   config = cfg;
2560   rounds_finished = 0;
2561   memset(&trial_info, 0, sizeof(struct GNUNET_DHTLOG_TrialInfo));
2562   /* Get path from configuration file */
2563   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
2564     {
2565       ok = 404;
2566       return;
2567     }
2568
2569   /**
2570    * Get DHT specific testing options.
2571    */
2572   if ((GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht_testing", "mysql_logging")) ||
2573       (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht_testing", "mysql_logging_extended")))
2574     {
2575       dhtlog_handle = GNUNET_DHTLOG_connect(cfg);
2576       if (dhtlog_handle == NULL)
2577         {
2578           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2579                       "Could not connect to mysql server for logging, will NOT log dht operations!");
2580           ok = 3306;
2581           return;
2582         }
2583     }
2584
2585   stop_closest = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "stop_on_closest");
2586   if (stop_closest == GNUNET_SYSERR)
2587     stop_closest = GNUNET_NO;
2588
2589   stop_found = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "stop_found");
2590   if (stop_found == GNUNET_SYSERR)
2591     stop_found = GNUNET_NO;
2592
2593   strict_kademlia = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "strict_kademlia");
2594   if (strict_kademlia == GNUNET_SYSERR)
2595     strict_kademlia = GNUNET_NO;
2596
2597   if (GNUNET_OK !=
2598       GNUNET_CONFIGURATION_get_value_string (cfg, "dht_testing", "comment",
2599                                              &trialmessage))
2600     trialmessage = NULL;
2601
2602   churn_data = NULL;
2603   /** Check for a churn file to do churny simulation */
2604   if (GNUNET_OK ==
2605       GNUNET_CONFIGURATION_get_value_string(cfg, "dht_testing", "churn_file",
2606                                             &churn_filename))
2607     {
2608       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Reading churn data from %s\n", churn_filename);
2609       if (GNUNET_OK != GNUNET_DISK_file_test (churn_filename))
2610         {
2611           GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error reading churn file!\n");
2612           GNUNET_free_non_null(trialmessage);
2613           GNUNET_free(churn_filename);
2614           return;
2615         }
2616       if ((0 != STAT (churn_filename, &frstat)) || (frstat.st_size == 0))
2617         {
2618           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2619                       "Could not open file specified for churn data, ending test!");
2620           ok = 1119;
2621           GNUNET_free_non_null(trialmessage);
2622           GNUNET_free(churn_filename);
2623           return;
2624         }
2625
2626       churn_data = GNUNET_malloc_large (frstat.st_size);
2627       GNUNET_assert(churn_data != NULL);
2628       if (frstat.st_size !=
2629           GNUNET_DISK_fn_read (churn_filename, churn_data, frstat.st_size))
2630         {
2631           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2632                     "Could not read file %s specified for churn, ending test!", churn_filename);
2633           GNUNET_free (churn_filename);
2634           GNUNET_free (churn_data);
2635           GNUNET_free_non_null(trialmessage);
2636           return;
2637         }
2638
2639       GNUNET_free_non_null(churn_filename);
2640
2641       buf = churn_data;
2642       count = 0;
2643       /* Read the first line */
2644       while (count < frstat.st_size)
2645         {
2646           count++;
2647           if (((churn_data[count] == '\n')) && (buf != &churn_data[count]))
2648             {
2649               churn_data[count] = '\0';
2650               if (1 != sscanf(buf, "%u", &churn_rounds))
2651                 {
2652                   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to read number of rounds from churn file, ending test!\n");
2653                   ret = 4200;
2654                   GNUNET_free_non_null(trialmessage);
2655                   GNUNET_free_non_null(churn_data);
2656                   return;
2657                 }
2658               GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Read %u rounds from churn file\n", churn_rounds);
2659               buf = &churn_data[count + 1];
2660               churn_array = GNUNET_malloc(sizeof(unsigned int) * churn_rounds);
2661               break; /* Done with this part */
2662             }
2663         }
2664
2665       if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, "dht_testing", "churns_per_round", &churns_per_round))
2666         {
2667           churns_per_round = (unsigned long long)churn_rounds;
2668         }
2669
2670       line_number = 0;
2671       while ((count < frstat.st_size) && (line_number < churn_rounds))
2672         {
2673           count++;
2674           if (((churn_data[count] == '\n')) && (buf != &churn_data[count]))
2675             {
2676               churn_data[count] = '\0';
2677
2678               ret = sscanf(buf, "%u", &churn_array[line_number]);
2679               if (1 == ret)
2680                 {
2681                   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Read %u peers in round %u\n", churn_array[line_number], line_number);
2682                   line_number++;
2683                 }
2684               else
2685                 {
2686                   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error reading line `%s' in hostfile\n", buf);
2687                   buf = &churn_data[count + 1];
2688                   continue;
2689                 }
2690               buf = &churn_data[count + 1];
2691             }
2692           else if (churn_data[count] == '\n') /* Blank line */
2693             buf = &churn_data[count + 1];
2694         }
2695     }
2696   GNUNET_free_non_null(churn_data);
2697
2698   /** Check for a hostfile containing user@host:port triples */
2699   if (GNUNET_OK !=
2700       GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "hostfile",
2701                                              &hostfile))
2702     hostfile = NULL;
2703
2704   hosts = NULL;
2705   temphost = NULL;
2706   data = NULL;
2707   if (hostfile != NULL)
2708     {
2709       if (GNUNET_OK != GNUNET_DISK_file_test (hostfile))
2710           GNUNET_DISK_fn_write (hostfile, NULL, 0, GNUNET_DISK_PERM_USER_READ
2711             | GNUNET_DISK_PERM_USER_WRITE);
2712       if ((0 != STAT (hostfile, &frstat)) || (frstat.st_size == 0))
2713         {
2714           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2715                       "Could not open file specified for host list, ending test!");
2716           ok = 1119;
2717           GNUNET_free_non_null(trialmessage);
2718           GNUNET_free(hostfile);
2719           return;
2720         }
2721
2722     data = GNUNET_malloc_large (frstat.st_size);
2723     GNUNET_assert(data != NULL);
2724     if (frstat.st_size !=
2725         GNUNET_DISK_fn_read (hostfile, data, frstat.st_size))
2726       {
2727         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2728                   "Could not read file %s specified for host list, ending test!", hostfile);
2729         GNUNET_free (hostfile);
2730         GNUNET_free (data);
2731         GNUNET_free_non_null(trialmessage);
2732         return;
2733       }
2734
2735     GNUNET_free_non_null(hostfile);
2736
2737     buf = data;
2738     count = 0;
2739     while (count < frstat.st_size)
2740       {
2741         count++;
2742         /* if (((data[count] == '\n') || (data[count] == '\0')) && (buf != &data[count]))*/
2743         if (((data[count] == '\n')) && (buf != &data[count]))
2744           {
2745             data[count] = '\0';
2746             temphost = GNUNET_malloc(sizeof(struct GNUNET_TESTING_Host));
2747             ret = sscanf(buf, "%a[a-zA-Z0-9]@%a[a-zA-Z0-9.]:%hd", &temphost->username, &temphost->hostname, &temphost->port);
2748             if (3 == ret)
2749               {
2750                 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Successfully read host %s, port %d and user %s from file\n", temphost->hostname, temphost->port, temphost->username);
2751               }
2752             else
2753               {
2754                 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error reading line `%s' in hostfile\n", buf);
2755                 GNUNET_free(temphost);
2756                 buf = &data[count + 1];
2757                 continue;
2758               }
2759             /* temphost->hostname = buf; */
2760             temphost->next = hosts;
2761             hosts = temphost;
2762             buf = &data[count + 1];
2763           }
2764         else if ((data[count] == '\n') || (data[count] == '\0'))
2765           buf = &data[count + 1];
2766       }
2767     }
2768   GNUNET_free_non_null(data);
2769   if (GNUNET_OK !=
2770           GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "malicious_getters",
2771                                                  &malicious_getters))
2772     malicious_getters = 0;
2773
2774   if (GNUNET_OK !=
2775           GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "malicious_putters",
2776                                                  &malicious_putters))
2777     malicious_putters = 0;
2778
2779   if (GNUNET_OK !=
2780             GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "malicious_droppers",
2781                                                    &malicious_droppers))
2782     malicious_droppers = 0;
2783
2784   if (GNUNET_OK !=
2785       GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "settle_time",
2786                                                  &settle_time))
2787     settle_time = 0;
2788
2789   if (GNUNET_SYSERR ==
2790       GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "num_puts",
2791                                              &num_puts))
2792     num_puts = num_peers;
2793
2794   if (GNUNET_SYSERR ==
2795       GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "put_replication",
2796                                              &put_replication))
2797     put_replication = DEFAULT_PUT_REPLICATION;
2798
2799   if (GNUNET_SYSERR ==
2800       GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "num_gets",
2801                                              &num_gets))
2802     num_gets = num_peers;
2803
2804   if (GNUNET_SYSERR ==
2805         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "get_replication",
2806                                                &get_replication))
2807       get_replication = DEFAULT_GET_REPLICATION;
2808
2809   if (GNUNET_OK ==
2810         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "find_peer_delay",
2811                                                &temp_config_number))
2812     find_peer_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2813   else
2814     find_peer_delay = DEFAULT_FIND_PEER_DELAY;
2815
2816   if (GNUNET_OK ==
2817         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "concurrent_find_peers",
2818                                                &temp_config_number))
2819     max_outstanding_find_peers = temp_config_number;
2820   else
2821     max_outstanding_find_peers = DEFAULT_MAX_OUTSTANDING_FIND_PEERS;
2822
2823   if (GNUNET_OK ==
2824         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "get_timeout",
2825                                                &temp_config_number))
2826     get_timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2827   else
2828     get_timeout = DEFAULT_GET_TIMEOUT;
2829
2830   if (GNUNET_OK ==
2831         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "concurrent_puts",
2832                                                &temp_config_number))
2833     max_outstanding_puts = temp_config_number;
2834   else
2835     max_outstanding_puts = DEFAULT_MAX_OUTSTANDING_PUTS;
2836
2837   if (GNUNET_OK ==
2838         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "concurrent_gets",
2839                                                &temp_config_number))
2840     max_outstanding_gets = temp_config_number;
2841   else
2842     max_outstanding_gets = DEFAULT_MAX_OUTSTANDING_GETS;
2843
2844   if (GNUNET_OK ==
2845         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "timeout",
2846                                                &temp_config_number))
2847     all_get_timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2848   else
2849     all_get_timeout.rel_value = get_timeout.rel_value * num_gets;
2850
2851   if (GNUNET_OK ==
2852         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "get_delay",
2853                                                &temp_config_number))
2854     get_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2855   else
2856     get_delay = DEFAULT_GET_DELAY;
2857
2858   if (GNUNET_OK ==
2859         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "put_delay",
2860                                                &temp_config_number))
2861     put_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2862   else
2863     put_delay = DEFAULT_PUT_DELAY;
2864
2865   if (GNUNET_OK ==
2866       GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "peer_start_timeout",
2867                                              &temp_config_number))
2868     seconds_per_peer_start = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2869   else
2870     seconds_per_peer_start = DEFAULT_SECONDS_PER_PEER_START;
2871
2872   if (GNUNET_OK ==
2873         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "data_size",
2874                                                &temp_config_number))
2875     test_data_size = temp_config_number;
2876   else
2877     test_data_size = DEFAULT_TEST_DATA_SIZE;
2878
2879   /**
2880    * Get testing related options.
2881    */
2882   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT_TESTING", "REPLICATE_SAME"))
2883     replicate_same = GNUNET_YES;
2884
2885   /**
2886    * Get testing related options.
2887    */
2888   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT_TESTING", "GET_FROM_SAME"))
2889     get_from_same = GNUNET_YES;
2890
2891
2892   if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_time (cfg, "DHT_TESTING",
2893                                                         "MALICIOUS_GET_FREQUENCY",
2894                                                         &malicious_get_frequency))
2895     malicious_get_frequency = DEFAULT_MALICIOUS_GET_FREQUENCY;
2896
2897
2898   if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_time (cfg, "DHT_TESTING",
2899                                                         "MALICIOUS_PUT_FREQUENCY",
2900                                                         &malicious_put_frequency))
2901     malicious_put_frequency = DEFAULT_MALICIOUS_PUT_FREQUENCY;
2902
2903
2904   /* The normal behavior of the DHT is to do find peer requests
2905    * on its own.  Only if this is explicitly turned off should
2906    * the testing driver issue find peer requests (even though
2907    * this is likely the default when testing).
2908    */
2909   if (GNUNET_NO ==
2910         GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht",
2911                                              "do_find_peer"))
2912     {
2913       do_find_peer = GNUNET_YES;
2914     }
2915
2916   if (GNUNET_YES ==
2917         GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht",
2918                                              "republish"))
2919     {
2920       in_dht_replication = GNUNET_YES;
2921     }
2922
2923   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING",
2924                                                           "TRIAL_TO_RUN",
2925                                                           &trial_to_run))
2926     {
2927       trial_to_run = 0;
2928     }
2929
2930   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING",
2931                                                           "FIND_PEER_DELAY",
2932                                                           &temp_config_number))
2933     {
2934       find_peer_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number);
2935     }
2936   else
2937     find_peer_delay = DEFAULT_FIND_PEER_DELAY;
2938
2939   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number(cfg, "DHT_TESTING", "ROUND_DELAY", &round_delay))
2940     round_delay = 0;
2941
2942   if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING",
2943                                                             "OUTSTANDING_FIND_PEERS",
2944                                                             &max_outstanding_find_peers))
2945       max_outstanding_find_peers = DEFAULT_MAX_OUTSTANDING_FIND_PEERS;
2946
2947   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "strict_kademlia"))
2948     max_outstanding_find_peers = max_outstanding_find_peers * 1;
2949
2950   find_peer_offset = GNUNET_TIME_relative_divide (find_peer_delay, max_outstanding_find_peers);
2951
2952   if (GNUNET_SYSERR ==
2953         GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "num_rounds",
2954                                                &total_rounds))
2955     {
2956       total_rounds = 1;
2957     }
2958
2959   topology_str = NULL;
2960   if ((GNUNET_YES ==
2961       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "topology",
2962                                             &topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&topology, topology_str)))
2963     {
2964       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2965                   "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "TOPOLOGY");
2966       topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */
2967     }
2968
2969   if (GNUNET_OK !=
2970       GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "percentage",
2971                                                  &topology_percentage_str))
2972     topology_percentage = 0.5;
2973   else
2974     {
2975       topology_percentage = atof (topology_percentage_str);
2976       GNUNET_free(topology_percentage_str);
2977     }
2978
2979   if (GNUNET_OK !=
2980       GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "probability",
2981                                                  &topology_probability_str))
2982     topology_probability = 0.5;
2983   else
2984     {
2985      topology_probability = atof (topology_probability_str);
2986      GNUNET_free(topology_probability_str);
2987     }
2988
2989   if ((GNUNET_YES ==
2990       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology",
2991                                             &connect_topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&connect_topology, connect_topology_str)))
2992     {
2993       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2994                   "Invalid connect topology `%s' given for section %s option %s\n", connect_topology_str, "TESTING", "CONNECT_TOPOLOGY");
2995     }
2996   GNUNET_free_non_null(connect_topology_str);
2997
2998   if ((GNUNET_YES ==
2999       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology_option",
3000                                             &connect_topology_option_str)) && (GNUNET_NO == GNUNET_TESTING_topology_option_get(&connect_topology_option, connect_topology_option_str)))
3001     {
3002       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3003                   "Invalid connect topology option `%s' given for section %s option %s\n", connect_topology_option_str, "TESTING", "CONNECT_TOPOLOGY_OPTION");
3004       connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */
3005     }
3006   GNUNET_free_non_null(connect_topology_option_str);
3007
3008   if (GNUNET_YES ==
3009         GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "connect_topology_option_modifier",
3010                                                &connect_topology_option_modifier_string))
3011     {
3012       if (sscanf(connect_topology_option_modifier_string, "%lf", &connect_topology_option_modifier) != 1)
3013       {
3014         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3015         _("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
3016         connect_topology_option_modifier_string,
3017         "connect_topology_option_modifier",
3018         "TESTING");
3019       }
3020       GNUNET_free (connect_topology_option_modifier_string);
3021     }
3022
3023   if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "blacklist_transports",
3024                                          &blacklist_transports))
3025     blacklist_transports = NULL;
3026
3027   if ((GNUNET_YES ==
3028       GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "blacklist_topology",
3029                                             &blacklist_topology_str)) &&
3030       (GNUNET_NO == GNUNET_TESTING_topology_get(&blacklist_topology, blacklist_topology_str)))
3031     {
3032       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3033                   "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "BLACKLIST_TOPOLOGY");
3034     }
3035   GNUNET_free_non_null(topology_str);
3036   GNUNET_free_non_null(blacklist_topology_str);
3037
3038   /* Get number of peers to start from configuration */
3039   if (GNUNET_SYSERR ==
3040       GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
3041                                              &num_peers))
3042     {
3043       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3044                   "Number of peers must be specified in section %s option %s\n", "TESTING", "NUM_PEERS");
3045     }
3046   GNUNET_assert(num_peers > 0 && num_peers < ULONG_MAX);
3047   /* Set peers_left so we know when all peers started */
3048   peers_left = num_peers;
3049
3050
3051   /* Set up a task to end testing if peer start fails */
3052   die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
3053                                            &end_badly, "didn't generate all hostkeys within allowed startup time!");
3054
3055   if (dhtlog_handle == NULL)
3056     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3057                 "dhtlog_handle is NULL!");
3058
3059   trial_info.other_identifier = (unsigned int)trial_to_run;
3060   trial_info.num_nodes = peers_left;
3061   trial_info.topology = topology;
3062   trial_info.blacklist_topology = blacklist_topology;
3063   trial_info.connect_topology = connect_topology;
3064   trial_info.connect_topology_option = connect_topology_option;
3065   trial_info.connect_topology_option_modifier = connect_topology_option_modifier;
3066   trial_info.topology_percentage = topology_percentage;
3067   trial_info.topology_probability = topology_probability;
3068   trial_info.puts = num_puts;
3069   trial_info.gets = num_gets;
3070   trial_info.concurrent = max_outstanding_gets;
3071   trial_info.settle_time = settle_time;
3072   trial_info.num_rounds = 1;
3073   trial_info.malicious_getters = malicious_getters;
3074   trial_info.malicious_putters = malicious_putters;
3075   trial_info.malicious_droppers = malicious_droppers;
3076   trial_info.malicious_get_frequency = malicious_get_frequency.rel_value;
3077   trial_info.malicious_put_frequency = malicious_put_frequency.rel_value;
3078   trial_info.stop_closest = stop_closest;
3079   trial_info.stop_found = stop_found;
3080   trial_info.strict_kademlia = strict_kademlia;
3081
3082   if (trialmessage != NULL)
3083     trial_info.message = trialmessage;
3084   else
3085     trial_info.message = "";
3086
3087   if (dhtlog_handle != NULL)
3088     dhtlog_handle->insert_trial(&trial_info);
3089
3090   GNUNET_free_non_null(trialmessage);
3091
3092   hostkey_meter = create_meter(peers_left, "Hostkeys created ", GNUNET_YES);
3093   peer_start_meter = create_meter(peers_left, "Peers started ", GNUNET_YES);
3094
3095   put_meter = create_meter(num_puts, "Puts completed ", GNUNET_YES);
3096   get_meter = create_meter(num_gets, "Gets completed ", GNUNET_YES);
3097   pg = GNUNET_TESTING_daemons_start (cfg,
3098                                      peers_left,
3099                                      GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers),
3100                                      &hostkey_callback, NULL,
3101                                      &peers_started_callback, NULL,
3102                                      &topology_callback, NULL,
3103                                      hosts);
3104   temphost = hosts;
3105   while (temphost != NULL)
3106     {
3107       tempnext = temphost->next;
3108       GNUNET_free (temphost->username);
3109       GNUNET_free (temphost->hostname);
3110       GNUNET_free (temphost);
3111       temphost = tempnext;
3112     }
3113 }
3114
3115 int
3116 main (int argc, char *argv[])
3117 {
3118   int ret;
3119   struct GNUNET_GETOPT_CommandLineOption options[] = {
3120       GNUNET_GETOPT_OPTION_END
3121     };
3122
3123   ret = GNUNET_PROGRAM_run (argc,
3124                             argv, "gnunet-dht-driver", "nohelp",
3125                             options, &run, &ok);
3126
3127   if (ret != GNUNET_OK)
3128     {
3129       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`gnunet-dht-driver': Failed with error code %d\n", ret);
3130     }
3131
3132   /**
3133    * Need to remove base directory, subdirectories taken care
3134    * of by the testing framework.
3135    */
3136   if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
3137     {
3138       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory);
3139     }
3140   return ret;
3141 }
3142
3143 /* end of gnunet-dht-driver.c */