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