src/rps/test_rps.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009, 2012 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20 /**
  21  * @file rps/test_rps.c
  22  * @brief Testcase for the random peer sampling service.  Starts
  23  *        a peergroup with a given number of peers, then waits to
  24  *        receive size pushes/pulls from each peer.  Expects to wait
  25  *        for one message from each peer.
  26  */
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_testbed_service.h"
  30
  31 #include "gnunet_rps_service.h"
  32 #include "rps-test_util.h"
  33 #include "gnunet-service-rps_sampler_elem.h"
  34
  35 #include <inttypes.h>
  36
  37
  38 /**
  39  * How many peers do we start?
  40  */
  41 static uint32_t num_peers;
  42
  43 /**
  44  * How long do we run the test?
  45  */
  46 //#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  47 static struct GNUNET_TIME_Relative timeout;
  48
  49
  50 /**
  51  * Portion of malicious peers
  52  */
  53 static double portion = .1;
  54
  55 /**
  56  * Type of malicious peer to test
  57  */
  58 static unsigned int mal_type = 0;
  59
  60 /**
  61  * Handles to all of the running peers
  62  */
  63 static struct GNUNET_TESTBED_Peer **testbed_peers;
  64
  65 /**
  66  * @brief Indicates whether peer should go off- or online
  67  */
  68 enum PEER_ONLINE_DELTA {
  69   /**
  70    * @brief Indicates peer going online
  71    */
  72   PEER_GO_ONLINE = 1,
  73   /**
  74    * @brief Indicates peer going offline
  75    */
  76   PEER_GO_OFFLINE = -1,
  77 };
  78
  79 /**
  80  * Operation map entry
  81  */
  82 struct OpListEntry
  83 {
  84   /**
  85    * DLL next ptr
  86    */
  87   struct OpListEntry *next;
  88
  89   /**
  90    * DLL prev ptr
  91    */
  92   struct OpListEntry *prev;
  93
  94   /**
  95    * The testbed operation
  96    */
  97   struct GNUNET_TESTBED_Operation *op;
  98
  99   /**
 100    * Depending on whether we start or stop RPS service at the peer, set this to
 101    * #PEER_GO_ONLINE (1) or #PEER_GO_OFFLINE (-1)
 102    */
 103   enum PEER_ONLINE_DELTA delta;
 104
 105   /**
 106    * Index of the regarding peer
 107    */
 108   unsigned int index;
 109 };
 110
 111 /**
 112  * OpList DLL head
 113  */
 114 static struct OpListEntry *oplist_head;
 115
 116 /**
 117  * OpList DLL tail
 118  */
 119 static struct OpListEntry *oplist_tail;
 120
 121
 122 /**
 123  * A pending reply: A request was sent and the reply is pending.
 124  */
 125 struct PendingReply
 126 {
 127   /**
 128    * DLL next,prev ptr
 129    */
 130   struct PendingReply *next;
 131   struct PendingReply *prev;
 132
 133   /**
 134    * Handle to the request we are waiting for
 135    */
 136   struct GNUNET_RPS_Request_Handle *req_handle;
 137
 138   /**
 139    * The peer that requested
 140    */
 141   struct RPSPeer *rps_peer;
 142 };
 143
 144
 145 /**
 146  * A pending request: A request was not made yet but is scheduled for later.
 147  */
 148 struct PendingRequest
 149 {
 150   /**
 151    * DLL next,prev ptr
 152    */
 153   struct PendingRequest *next;
 154   struct PendingRequest *prev;
 155
 156   /**
 157    * Handle to the request we are waiting for
 158    */
 159   struct GNUNET_SCHEDULER_Task *request_task;
 160
 161   /**
 162    * The peer that requested
 163    */
 164   struct RPSPeer *rps_peer;
 165 };
 166
 167
 168 /**
 169  * Information we track for each peer.
 170  */
 171 struct RPSPeer
 172 {
 173   /**
 174    * Index of the peer.
 175    */
 176   unsigned int index;
 177
 178   /**
 179    * Handle for RPS connect operation.
 180    */
 181   struct GNUNET_TESTBED_Operation *op;
 182
 183   /**
 184    * Handle to RPS service.
 185    */
 186   struct GNUNET_RPS_Handle *rps_handle;
 187
 188   /**
 189    * ID of the peer.
 190    */
 191   struct GNUNET_PeerIdentity *peer_id;
 192
 193   /**
 194    * A request handle to check for an request
 195    */
 196   //struct GNUNET_RPS_Request_Handle *req_handle;
 197
 198   /**
 199    * Peer on- or offline?
 200    */
 201   int online;
 202
 203   /**
 204    * Number of Peer IDs to request during the whole test
 205    */
 206   unsigned int num_ids_to_request;
 207
 208   /**
 209    * Pending requests DLL
 210    */
 211   struct PendingRequest *pending_req_head;
 212   struct PendingRequest *pending_req_tail;
 213
 214   /**
 215    * Number of pending requests
 216    */
 217   unsigned int num_pending_reqs;
 218
 219   /**
 220    * Pending replies DLL
 221    */
 222   struct PendingReply *pending_rep_head;
 223   struct PendingReply *pending_rep_tail;
 224
 225   /**
 226    * Number of pending replies
 227    */
 228   unsigned int num_pending_reps;
 229
 230   /**
 231    * Number of received PeerIDs
 232    */
 233   unsigned int num_recv_ids;
 234
 235   /**
 236    * Pending operation on that peer
 237    */
 238   const struct OpListEntry *entry_op_manage;
 239
 240   /**
 241    * Testbed operation to connect to statistics service
 242    */
 243   struct GNUNET_TESTBED_Operation *stat_op;
 244
 245   /**
 246    * Handle to the statistics service
 247    */
 248   struct GNUNET_STATISTICS_Handle *stats_h;
 249
 250   /**
 251    * @brief flags to indicate which statistics values have been already
 252    * collected from the statistics service.
 253    * Used to check whether we are able to shutdown.
 254    */
 255   uint32_t stat_collected_flags;
 256
 257   /**
 258    * @brief File name of the file the stats are finally written to
 259    */
 260   const char *file_name_stats;
 261
 262   /**
 263    * @brief File name of the file the stats are finally written to
 264    */
 265   const char *file_name_probs;
 266
 267   /**
 268    * @brief The current view
 269    */
 270   struct GNUNET_PeerIdentity *cur_view;
 271
 272   /**
 273    * @brief Number of peers in the #cur_view.
 274    */
 275   uint32_t cur_view_count;
 276
 277   /**
 278    * @brief Number of occurrences in other peer's view
 279    */
 280   uint32_t count_in_views;
 281
 282   /**
 283    * @brief statistics values
 284    */
 285   uint64_t num_rounds;
 286   uint64_t num_blocks;
 287   uint64_t num_blocks_many_push;
 288   uint64_t num_blocks_no_push;
 289   uint64_t num_blocks_no_pull;
 290   uint64_t num_blocks_many_push_no_pull;
 291   uint64_t num_blocks_no_push_no_pull;
 292   uint64_t num_issued_push;
 293   uint64_t num_issued_pull_req;
 294   uint64_t num_issued_pull_rep;
 295   uint64_t num_sent_push;
 296   uint64_t num_sent_pull_req;
 297   uint64_t num_sent_pull_rep;
 298   uint64_t num_recv_push;
 299   uint64_t num_recv_pull_req;
 300   uint64_t num_recv_pull_rep;
 301 };
 302
 303 enum STAT_TYPE
 304 {
 305   STAT_TYPE_ROUNDS                    =    0x1, /*   1 */
 306   STAT_TYPE_BLOCKS                    =    0x2, /*   2 */
 307   STAT_TYPE_BLOCKS_MANY_PUSH          =    0x4, /*   3 */
 308   STAT_TYPE_BLOCKS_NO_PUSH            =    0x8, /*   4 */
 309   STAT_TYPE_BLOCKS_NO_PULL            =   0x10, /*   5 */
 310   STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL  =   0x20, /*   6 */
 311   STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL    =   0x40, /*   7 */
 312   STAT_TYPE_ISSUED_PUSH_SEND          =   0x80, /*   8 */
 313   STAT_TYPE_ISSUED_PULL_REQ           =  0x100, /*   9 */
 314   STAT_TYPE_ISSUED_PULL_REP           =  0x200, /*  10 */
 315   STAT_TYPE_SENT_PUSH_SEND            =  0x400, /*  11 */
 316   STAT_TYPE_SENT_PULL_REQ             =  0x800, /*  12 */
 317   STAT_TYPE_SENT_PULL_REP             = 0x1000, /*  13 */
 318   STAT_TYPE_RECV_PUSH_SEND            = 0x2000, /*  14 */
 319   STAT_TYPE_RECV_PULL_REQ             = 0x4000, /*  15 */
 320   STAT_TYPE_RECV_PULL_REP             = 0x8000, /*  16 */
 321   STAT_TYPE_MAX          = 0x80000000, /*  32 */
 322 };
 323
 324 struct STATcls
 325 {
 326   struct RPSPeer *rps_peer;
 327   enum STAT_TYPE stat_type;
 328 };
 329
 330
 331 /**
 332  * Information for all the peers.
 333  */
 334 static struct RPSPeer *rps_peers;
 335
 336 /**
 337  * Peermap to get the index of a given peer ID quick.
 338  */
 339 static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
 340
 341 /**
 342  * IDs of the peers.
 343  */
 344 static struct GNUNET_PeerIdentity *rps_peer_ids;
 345
 346 /**
 347  * ID of the targeted peer.
 348  */
 349 static struct GNUNET_PeerIdentity *target_peer;
 350
 351 /**
 352  * ID of the peer that requests for the evaluation.
 353  */
 354 static struct RPSPeer *eval_peer;
 355
 356 /**
 357  * Number of online peers.
 358  */
 359 static unsigned int num_peers_online;
 360
 361 /**
 362  * @brief The added sizes of the peer's views
 363  */
 364 static unsigned int view_sizes;
 365
 366 /**
 367  * Return value from 'main'.
 368  */
 369 static int ok;
 370
 371 /**
 372  * Identifier for the churn task that runs periodically
 373  */
 374 static struct GNUNET_SCHEDULER_Task *shutdown_task;
 375
 376 /**
 377  * Identifier for the churn task that runs periodically
 378  */
 379 static struct GNUNET_SCHEDULER_Task *churn_task;
 380
 381 /**
 382  * Called to initialise the given RPSPeer
 383  */
 384 typedef void (*InitPeer) (struct RPSPeer *rps_peer);
 385
 386 /**
 387  * @brief Called directly after connecting to the service
 388  *
 389  * @param rps_peer Specific peer the function is called on
 390  * @param h the handle to the rps service
 391  */
 392 typedef void (*PreTest) (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h);
 393
 394 /**
 395  * @brief Executes functions to test the api/service for a given peer
 396  *
 397  * Called from within #rps_connect_complete_cb ()
 398  * Implemented by #churn_test_cb, #profiler_cb, #mal_cb, #single_req_cb,
 399  * #delay_req_cb, #seed_big_cb, #single_peer_seed_cb, #seed_cb, #req_cancel_cb
 400  *
 401  * @param rps_peer the peer the task runs on
 402  */
 403 typedef void (*MainTest) (struct RPSPeer *rps_peer);
 404
 405 /**
 406  * Callback called once the requested random peers are available
 407  */
 408 typedef void (*ReplyHandle) (void *cls,
 409                              uint64_t n,
 410                              const struct GNUNET_PeerIdentity *recv_peers);
 411
 412 /**
 413  * Called directly before disconnecting from the service
 414  */
 415 typedef void (*PostTest) (struct RPSPeer *peer);
 416
 417 /**
 418  * Function called after disconnect to evaluate test success
 419  */
 420 typedef int (*EvaluationCallback) (void);
 421
 422 /**
 423  * @brief Do we have Churn?
 424  */
 425 enum OPTION_CHURN {
 426   /**
 427    * @brief If we have churn this is set
 428    */
 429   HAVE_CHURN,
 430   /**
 431    * @brief If we have no churn this is set
 432    */
 433   HAVE_NO_CHURN,
 434 };
 435
 436 /**
 437  * @brief Is it ok to quit the test before the timeout?
 438  */
 439 enum OPTION_QUICK_QUIT {
 440   /**
 441    * @brief It is ok for the test to quit before the timeout triggers
 442    */
 443   HAVE_QUICK_QUIT,
 444
 445   /**
 446    * @brief It is NOT ok for the test to quit before the timeout triggers
 447    */
 448   HAVE_NO_QUICK_QUIT,
 449 };
 450
 451 /**
 452  * @brief Do we collect statistics at the end?
 453  */
 454 enum OPTION_COLLECT_STATISTICS {
 455   /**
 456    * @brief We collect statistics at the end
 457    */
 458   COLLECT_STATISTICS,
 459
 460   /**
 461    * @brief We do not collect statistics at the end
 462    */
 463   NO_COLLECT_STATISTICS,
 464 };
 465
 466 /**
 467  * @brief Do we collect views during run?
 468  */
 469 enum OPTION_COLLECT_VIEW {
 470   /**
 471    * @brief We collect view during run
 472    */
 473   COLLECT_VIEW,
 474
 475   /**
 476    * @brief We do not collect the view during run
 477    */
 478   NO_COLLECT_VIEW,
 479 };
 480
 481 /**
 482  * Structure to define a single test
 483  */
 484 struct SingleTestRun
 485 {
 486   /**
 487    * Name of the test
 488    */
 489   char *name;
 490
 491   /**
 492    * Called with a single peer in order to initialise that peer
 493    */
 494   InitPeer init_peer;
 495
 496   /**
 497    * Called directly after connecting to the service
 498    */
 499   PreTest pre_test;
 500
 501   /**
 502    * Main function for each peer
 503    */
 504   MainTest main_test;
 505
 506   /**
 507    * Callback called once the requested peers are available
 508    */
 509   ReplyHandle reply_handle;
 510
 511   /**
 512    * Called directly before disconnecting from the service
 513    */
 514   PostTest post_test;
 515
 516   /**
 517    * Function to evaluate the test results
 518    */
 519   EvaluationCallback eval_cb;
 520
 521   /**
 522    * Request interval
 523    */
 524   uint32_t request_interval;
 525
 526   /**
 527    * Number of Requests to make.
 528    */
 529   uint32_t num_requests;
 530
 531   /**
 532    * Run with (-out) churn
 533    */
 534   enum OPTION_CHURN have_churn;
 535
 536   /**
 537    * Quit test before timeout?
 538    */
 539   enum OPTION_QUICK_QUIT have_quick_quit;
 540
 541   /**
 542    * Collect statistics at the end?
 543    */
 544   enum OPTION_COLLECT_STATISTICS have_collect_statistics;
 545
 546   /**
 547    * Collect view during run?
 548    */
 549   enum OPTION_COLLECT_VIEW have_collect_view;
 550
 551   /**
 552    * @brief Mark which values from the statistics service to collect at the end
 553    * of the run
 554    */
 555   uint32_t stat_collect_flags;
 556 } cur_test_run;
 557
 558 /**
 559  * Are we shutting down?
 560  */
 561 static int in_shutdown;
 562
 563 /**
 564  * Append arguments to file
 565  */
 566 static void
 567 tofile_ (const char *file_name, const char *line)
 568 {
 569   struct GNUNET_DISK_FileHandle *f;
 570   /* char output_buffer[512]; */
 571   size_t size;
 572   /* int size; */
 573   size_t size2;
 574
 575   if (NULL == (f = GNUNET_DISK_file_open (file_name,
 576                                           GNUNET_DISK_OPEN_APPEND |
 577                                           GNUNET_DISK_OPEN_WRITE |
 578                                           GNUNET_DISK_OPEN_CREATE,
 579                                           GNUNET_DISK_PERM_USER_READ |
 580                                           GNUNET_DISK_PERM_USER_WRITE |
 581                                           GNUNET_DISK_PERM_GROUP_READ |
 582                                           GNUNET_DISK_PERM_OTHER_READ)))
 583   {
 584     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 585                 "Not able to open file %s\n",
 586                 file_name);
 587     return;
 588   }
 589   /* size = GNUNET_snprintf (output_buffer,
 590                           sizeof (output_buffer),
 591                           "%llu %s\n",
 592                           GNUNET_TIME_absolute_get ().abs_value_us,
 593                           line);
 594   if (0 > size)
 595   {
 596     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 597                 "Failed to write string to buffer (size: %i)\n",
 598                 size);
 599     return;
 600   } */
 601
 602   size = strlen (line) * sizeof (char);
 603
 604   size2 = GNUNET_DISK_file_write (f, line, size);
 605   if (size != size2)
 606   {
 607     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 608                 "Unable to write to file! (Size: %lu, size2: %lu)\n",
 609                 size,
 610                 size2);
 611     if (GNUNET_YES != GNUNET_DISK_file_close (f))
 612     {
 613       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 614                   "Unable to close file\n");
 615     }
 616     return;
 617   }
 618
 619   if (GNUNET_YES != GNUNET_DISK_file_close (f))
 620   {
 621     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 622                 "Unable to close file\n");
 623   }
 624 }
 625
 626 /**
 627  * This function is used to facilitate writing important information to disk
 628  */
 629 #define tofile(file_name, ...) do {\
 630   char tmp_buf[512];\
 631     int size;\
 632     size = GNUNET_snprintf(tmp_buf,sizeof(tmp_buf),__VA_ARGS__);\
 633     if (0 > size)\
 634       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,\
 635                      "Failed to create tmp_buf\n");\
 636     else\
 637       tofile_(file_name,tmp_buf);\
 638   } while (0);
 639
 640
 641 /**
 642  * Write the ids and their according index in the given array to a file
 643  * Unused
 644  */
 645 /* static void
 646 ids_to_file (char *file_name,
 647              struct GNUNET_PeerIdentity *peer_ids,
 648              unsigned int num_peer_ids)
 649 {
 650   unsigned int i;
 651
 652   for (i=0 ; i < num_peer_ids ; i++)
 653   {
 654     to_file (file_name,
 655              "%u\t%s",
 656              i,
 657              GNUNET_i2s_full (&peer_ids[i]));
 658   }
 659 } */
 660
 661 /**
 662  * Test the success of a single test
 663  */
 664 static int
 665 evaluate (void)
 666 {
 667   unsigned int i;
 668   int tmp_ok;
 669
 670   tmp_ok = 1;
 671
 672   for (i = 0; i < num_peers; i++)
 673   {
 674     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 675         "%u. peer [%s] received %u of %u expected peer_ids: %i\n",
 676         i,
 677         GNUNET_i2s (rps_peers[i].peer_id),
 678         rps_peers[i].num_recv_ids,
 679         rps_peers[i].num_ids_to_request,
 680         (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids));
 681     tmp_ok &= (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids);
 682   }
 683   return tmp_ok? 0 : 1;
 684 }
 685
 686
 687 /**
 688  * Creates an oplist entry and adds it to the oplist DLL
 689  */
 690 static struct OpListEntry *
 691 make_oplist_entry ()
 692 {
 693   struct OpListEntry *entry;
 694
 695   entry = GNUNET_new (struct OpListEntry);
 696   GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
 697   return entry;
 698 }
 699
 700
 701 /**
 702  * @brief Checks if given peer already received its statistics value from the
 703  * statistics service.
 704  *
 705  * @param rps_peer the peer to check for
 706  *
 707  * @return #GNUNET_YES if so
 708  *         #GNUNET_NO otherwise
 709  */
 710 static int check_statistics_collect_completed_single_peer (
 711     const struct RPSPeer *rps_peer)
 712 {
 713   if (cur_test_run.stat_collect_flags !=
 714         (cur_test_run.stat_collect_flags &
 715           rps_peer->stat_collected_flags))
 716   {
 717     return GNUNET_NO;
 718   }
 719   return GNUNET_YES;
 720 }
 721 /**
 722  * @brief Checks if all peers already received their statistics value from the
 723  * statistics service.
 724  *
 725  * @return #GNUNET_YES if so
 726  *         #GNUNET_NO otherwise
 727  */
 728 static int check_statistics_collect_completed ()
 729 {
 730   uint32_t i;
 731
 732   for (i = 0; i < num_peers; i++)
 733   {
 734     if (GNUNET_NO == check_statistics_collect_completed_single_peer (&rps_peers[i]))
 735     {
 736       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 737           "At least Peer %" PRIu32 " did not yet receive all statistics values\n",
 738           i);
 739       return GNUNET_NO;
 740     }
 741   }
 742   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 743       "All peers received their statistics values\n");
 744   return GNUNET_YES;
 745 }
 746
 747 /**
 748  * Task run on timeout to shut everything down.
 749  */
 750 static void
 751 shutdown_op (void *cls)
 752 {
 753   unsigned int i;
 754
 755   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 756               "Shutdown task scheduled, going down.\n");
 757   in_shutdown = GNUNET_YES;
 758   if (NULL != churn_task)
 759   {
 760     GNUNET_SCHEDULER_cancel (churn_task);
 761     churn_task = NULL;
 762   }
 763   for (i = 0; i < num_peers; i++)
 764   {
 765     if (NULL != rps_peers[i].op)
 766       GNUNET_TESTBED_operation_done (rps_peers[i].op);
 767     if (NULL != cur_test_run.post_test)
 768     {
 769       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing post_test for peer %u\n", i);
 770       cur_test_run.post_test (&rps_peers[i]);
 771     }
 772   }
 773   /* If we do not collect statistics, shut down directly */
 774   if (NO_COLLECT_STATISTICS == cur_test_run.have_collect_statistics ||
 775       GNUNET_YES == check_statistics_collect_completed())
 776   {
 777     GNUNET_SCHEDULER_shutdown ();
 778   }
 779 }
 780
 781
 782 /**
 783  * Seed peers.
 784  */
 785 static void
 786 seed_peers (void *cls)
 787 {
 788   struct RPSPeer *peer = cls;
 789   unsigned int amount;
 790   unsigned int i;
 791
 792   // TODO if malicious don't seed mal peers
 793   amount = round (.5 * num_peers);
 794
 795   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding peers:\n");
 796   for (i = 0 ; i < amount ; i++)
 797     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding %u. peer: %s\n",
 798                 i,
 799                 GNUNET_i2s (&rps_peer_ids[i]));
 800
 801   GNUNET_RPS_seed_ids (peer->rps_handle, amount, rps_peer_ids);
 802 }
 803
 804
 805 /**
 806  * Seed peers.
 807  */
 808 static void
 809 seed_peers_big (void *cls)
 810 {
 811   struct RPSPeer *peer = cls;
 812   unsigned int seed_msg_size;
 813   uint32_t num_peers_max;
 814   unsigned int amount;
 815   unsigned int i;
 816
 817   seed_msg_size = 8; /* sizeof (struct GNUNET_RPS_CS_SeedMessage) */
 818   num_peers_max = (GNUNET_MAX_MESSAGE_SIZE - seed_msg_size) /
 819     sizeof (struct GNUNET_PeerIdentity);
 820   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 821       "Peers that fit in one seed msg; %u\n",
 822       num_peers_max);
 823   amount = num_peers_max + (0.5 * num_peers_max);
 824   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 825       "Seeding many (%u) peers:\n",
 826       amount);
 827   struct GNUNET_PeerIdentity ids_to_seed[amount];
 828   for (i = 0; i < amount; i++)
 829   {
 830     ids_to_seed[i] = *peer->peer_id;
 831     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding %u. peer: %s\n",
 832                 i,
 833                 GNUNET_i2s (&ids_to_seed[i]));
 834   }
 835
 836   GNUNET_RPS_seed_ids (peer->rps_handle, amount, ids_to_seed);
 837 }
 838
 839 /**
 840  * Get the id of peer i.
 841  */
 842   void
 843 info_cb (void *cb_cls,
 844          struct GNUNET_TESTBED_Operation *op,
 845          const struct GNUNET_TESTBED_PeerInformation *pinfo,
 846          const char *emsg)
 847 {
 848   struct OpListEntry *entry = (struct OpListEntry *) cb_cls;
 849
 850   if (GNUNET_YES == in_shutdown)
 851   {
 852     return;
 853   }
 854
 855   if (NULL == pinfo || NULL != emsg)
 856   {
 857     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got Error: %s\n", emsg);
 858     GNUNET_TESTBED_operation_done (entry->op);
 859     return;
 860   }
 861
 862   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 863               "Peer %u is %s\n",
 864               entry->index,
 865               GNUNET_i2s (pinfo->result.id));
 866
 867   rps_peer_ids[entry->index] = *(pinfo->result.id);
 868   rps_peers[entry->index].peer_id = &rps_peer_ids[entry->index];
 869
 870   GNUNET_assert (GNUNET_OK ==
 871       GNUNET_CONTAINER_multipeermap_put (peer_map,
 872         &rps_peer_ids[entry->index],
 873         &rps_peers[entry->index],
 874         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 875   tofile ("/tmp/rps/peer_ids",
 876            "%u\t%s\n",
 877            entry->index,
 878            GNUNET_i2s_full (&rps_peer_ids[entry->index]));
 879
 880   GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
 881   GNUNET_TESTBED_operation_done (entry->op);
 882   GNUNET_free (entry);
 883 }
 884
 885
 886 /**
 887  * Callback to be called when RPS service connect operation is completed
 888  *
 889  * @param cls the callback closure from functions generating an operation
 890  * @param op the operation that has been finished
 891  * @param ca_result the RPS service handle returned from rps_connect_adapter
 892  * @param emsg error message in case the operation has failed; will be NULL if
 893  *          operation has executed successfully.
 894  */
 895 static void
 896 rps_connect_complete_cb (void *cls,
 897                          struct GNUNET_TESTBED_Operation *op,
 898                          void *ca_result,
 899                          const char *emsg)
 900 {
 901   struct RPSPeer *rps_peer = cls;
 902   struct GNUNET_RPS_Handle *rps = ca_result;
 903
 904   if (GNUNET_YES == in_shutdown)
 905   {
 906     return;
 907   }
 908
 909   rps_peer->rps_handle = rps;
 910   rps_peer->online = GNUNET_YES;
 911   num_peers_online++;
 912
 913   GNUNET_assert (op == rps_peer->op);
 914   if (NULL != emsg)
 915   {
 916     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 917                 "Failed to connect to RPS service: %s\n",
 918                 emsg);
 919     ok = 1;
 920     GNUNET_SCHEDULER_shutdown ();
 921     return;
 922   }
 923
 924   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started client successfully\n");
 925
 926   cur_test_run.main_test (rps_peer);
 927 }
 928
 929
 930 /**
 931  * Adapter function called to establish a connection to
 932  * the RPS service.
 933  *
 934  * @param cls closure
 935  * @param cfg configuration of the peer to connect to; will be available until
 936  *          GNUNET_TESTBED_operation_done() is called on the operation returned
 937  *          from GNUNET_TESTBED_service_connect()
 938  * @return service handle to return in 'op_result', NULL on error
 939  */
 940 static void *
 941 rps_connect_adapter (void *cls,
 942                                  const struct GNUNET_CONFIGURATION_Handle *cfg)
 943 {
 944   struct GNUNET_RPS_Handle *h;
 945
 946   h = GNUNET_RPS_connect (cfg);
 947
 948   if (NULL != cur_test_run.pre_test)
 949     cur_test_run.pre_test (cls, h);
 950
 951   return h;
 952 }
 953
 954 /**
 955  * Called to open a connection to the peer's statistics
 956  *
 957  * @param cls peer context
 958  * @param cfg configuration of the peer to connect to; will be available until
 959  *          GNUNET_TESTBED_operation_done() is called on the operation returned
 960  *          from GNUNET_TESTBED_service_connect()
 961  * @return service handle to return in 'op_result', NULL on error
 962  */
 963 static void *
 964 stat_connect_adapter (void *cls,
 965                       const struct GNUNET_CONFIGURATION_Handle *cfg)
 966 {
 967   struct RPSPeer *peer = cls;
 968
 969   peer->stats_h = GNUNET_STATISTICS_create ("rps-profiler", cfg);
 970   return peer->stats_h;
 971 }
 972
 973 /**
 974  * Called to disconnect from peer's statistics service
 975  *
 976  * @param cls peer context
 977  * @param op_result service handle returned from the connect adapter
 978  */
 979 static void
 980 stat_disconnect_adapter (void *cls, void *op_result)
 981 {
 982   struct RPSPeer *peer = cls;
 983
 984   //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
 985   //              (peer->stats_h, "core", "# peers connected",
 986   //               stat_iterator, peer));
 987   //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
 988   //              (peer->stats_h, "nse", "# peers connected",
 989   //               stat_iterator, peer));
 990   GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
 991   peer->stats_h = NULL;
 992 }
 993
 994 /**
 995  * Called after successfully opening a connection to a peer's statistics
 996  * service; we register statistics monitoring for CORE and NSE here.
 997  *
 998  * @param cls the callback closure from functions generating an operation
 999  * @param op the operation that has been finished
1000  * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter()
1001  * @param emsg error message in case the operation has failed; will be NULL if
1002  *          operation has executed successfully.
1003  */
1004 static void
1005 stat_complete_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
1006                   void *ca_result, const char *emsg )
1007 {
1008   //struct GNUNET_STATISTICS_Handle *sh = ca_result;
1009   //struct RPSPeer *peer = (struct RPSPeer *) cls;
1010
1011   if (NULL != emsg)
1012   {
1013     GNUNET_break (0);
1014     return;
1015   }
1016   //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
1017   //              (sh, "core", "# peers connected",
1018   //               stat_iterator, peer));
1019   //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
1020   //              (sh, "nse", "# peers connected",
1021   //               stat_iterator, peer));
1022 }
1023
1024
1025 /**
1026  * Adapter function called to destroy connection to
1027  * RPS service.
1028  *
1029  * @param cls closure
1030  * @param op_result service handle returned from the connect adapter
1031  */
1032 static void
1033 rps_disconnect_adapter (void *cls,
1034                                           void *op_result)
1035 {
1036   struct RPSPeer *peer = cls;
1037   struct GNUNET_RPS_Handle *h = op_result;
1038   GNUNET_assert (NULL != peer);
1039   GNUNET_RPS_disconnect (h);
1040   peer->rps_handle = NULL;
1041 }
1042
1043
1044 /***********************************************************************
1045  * Definition of tests
1046 ***********************************************************************/
1047
1048 // TODO check whether tests can be stopped earlier
1049 static int
1050 default_eval_cb (void)
1051 {
1052   return evaluate ();
1053 }
1054
1055 static int
1056 no_eval (void)
1057 {
1058   return 0;
1059 }
1060
1061 /**
1062  * Initialise given RPSPeer
1063  */
1064 static void default_init_peer (struct RPSPeer *rps_peer)
1065 {
1066   rps_peer->num_ids_to_request = 1;
1067 }
1068
1069 /**
1070  * Callback to call on receipt of a reply
1071  *
1072  * @param cls closure
1073  * @param n number of peers
1074  * @param recv_peers the received peers
1075  */
1076 static void
1077 default_reply_handle (void *cls,
1078                       uint64_t n,
1079                       const struct GNUNET_PeerIdentity *recv_peers)
1080 {
1081   struct RPSPeer *rps_peer;
1082   struct PendingReply *pending_rep = (struct PendingReply *) cls;
1083   unsigned int i;
1084
1085   rps_peer = pending_rep->rps_peer;
1086   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
1087                                rps_peer->pending_rep_tail,
1088                                pending_rep);
1089   rps_peer->num_pending_reps--;
1090   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1091               "[%s] got %" PRIu64 " peers:\n",
1092               GNUNET_i2s (rps_peer->peer_id),
1093               n);
1094
1095   for (i = 0; i < n; i++)
1096   {
1097     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1098                 "%u: %s\n",
1099                 i,
1100                 GNUNET_i2s (&recv_peers[i]));
1101
1102     rps_peer->num_recv_ids++;
1103   }
1104
1105   if (0 == evaluate () && HAVE_QUICK_QUIT == cur_test_run.have_quick_quit)
1106   {
1107     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test succeeded before timeout\n");
1108     GNUNET_assert (NULL != shutdown_task);
1109     GNUNET_SCHEDULER_cancel (shutdown_task);
1110     shutdown_task = GNUNET_SCHEDULER_add_now (&shutdown_op, NULL);
1111     GNUNET_assert (NULL!= shutdown_task);
1112   }
1113 }
1114
1115 /**
1116  * Request random peers.
1117  */
1118 static void
1119 request_peers (void *cls)
1120 {
1121   struct PendingRequest *pending_req = cls;
1122   struct RPSPeer *rps_peer;
1123   struct PendingReply *pending_rep;
1124
1125   if (GNUNET_YES == in_shutdown)
1126     return;
1127   rps_peer = pending_req->rps_peer;
1128   GNUNET_assert (1 <= rps_peer->num_pending_reqs);
1129   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
1130                                rps_peer->pending_req_tail,
1131                                pending_req);
1132   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1133               "Requesting one peer\n");
1134   pending_rep = GNUNET_new (struct PendingReply);
1135   pending_rep->rps_peer = rps_peer;
1136   pending_rep->req_handle = GNUNET_RPS_request_peers (rps_peer->rps_handle,
1137       1,
1138       cur_test_run.reply_handle,
1139       pending_rep);
1140   GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_rep_head,
1141                                     rps_peer->pending_rep_tail,
1142                                     pending_rep);
1143   rps_peer->num_pending_reps++;
1144   rps_peer->num_pending_reqs--;
1145 }
1146
1147 static void
1148 cancel_pending_req (struct PendingRequest *pending_req)
1149 {
1150   struct RPSPeer *rps_peer;
1151
1152   rps_peer = pending_req->rps_peer;
1153   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
1154                                rps_peer->pending_req_tail,
1155                                pending_req);
1156   rps_peer->num_pending_reqs--;
1157   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1158               "Cancelling pending request\n");
1159   GNUNET_SCHEDULER_cancel (pending_req->request_task);
1160   GNUNET_free (pending_req);
1161 }
1162
1163 static void
1164 cancel_request (struct PendingReply *pending_rep)
1165 {
1166   struct RPSPeer *rps_peer;
1167
1168   rps_peer = pending_rep->rps_peer;
1169   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
1170                                rps_peer->pending_rep_tail,
1171                                pending_rep);
1172   rps_peer->num_pending_reps--;
1173   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1174               "Cancelling request\n");
1175   GNUNET_RPS_request_cancel (pending_rep->req_handle);
1176   GNUNET_free (pending_rep);
1177 }
1178
1179 /**
1180  * Cancel a request.
1181  */
1182 static void
1183 cancel_request_cb (void *cls)
1184 {
1185   struct RPSPeer *rps_peer = cls;
1186   struct PendingReply *pending_rep;
1187
1188   if (GNUNET_YES == in_shutdown)
1189     return;
1190   pending_rep = rps_peer->pending_rep_head;
1191   GNUNET_assert (1 <= rps_peer->num_pending_reps);
1192   cancel_request (pending_rep);
1193 }
1194
1195
1196 /**
1197  * Schedule requests for peer @a rps_peer that have neither been scheduled, nor
1198  * issued, nor replied
1199  */
1200 void
1201 schedule_missing_requests (struct RPSPeer *rps_peer)
1202 {
1203   unsigned int i;
1204   struct PendingRequest *pending_req;
1205
1206   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1207       "Scheduling %u - %u missing requests\n",
1208       rps_peer->num_ids_to_request,
1209       rps_peer->num_pending_reqs + rps_peer->num_pending_reps);
1210   GNUNET_assert (rps_peer->num_pending_reqs + rps_peer->num_pending_reps <=
1211       rps_peer->num_ids_to_request);
1212   for (i = rps_peer->num_pending_reqs + rps_peer->num_pending_reps;
1213        i < rps_peer->num_ids_to_request; i++)
1214   {
1215     pending_req = GNUNET_new (struct PendingRequest);
1216     pending_req->rps_peer = rps_peer;
1217     pending_req->request_task = GNUNET_SCHEDULER_add_delayed (
1218         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
1219           cur_test_run.request_interval * i),
1220         request_peers,
1221         pending_req);
1222     GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_req_head,
1223                                       rps_peer->pending_req_tail,
1224                                       pending_req);
1225     rps_peer->num_pending_reqs++;
1226   }
1227 }
1228
1229 void
1230 cancel_pending_req_rep (struct RPSPeer *rps_peer)
1231 {
1232   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1233       "Cancelling all (pending) requests.\n");
1234   while (NULL != rps_peer->pending_req_head)
1235     cancel_pending_req (rps_peer->pending_req_head);
1236   GNUNET_assert (0 == rps_peer->num_pending_reqs);
1237   while (NULL != rps_peer->pending_rep_head)
1238     cancel_request (rps_peer->pending_rep_head);
1239   GNUNET_assert (0 == rps_peer->num_pending_reps);
1240 }
1241
1242 /***********************************
1243  * MALICIOUS
1244 ***********************************/
1245
1246 /**
1247  * Initialise only non-mal RPSPeers
1248  */
1249 static void mal_init_peer (struct RPSPeer *rps_peer)
1250 {
1251   if (rps_peer->index >= round (portion * num_peers))
1252     rps_peer->num_ids_to_request = 1;
1253 }
1254
1255
1256 /**
1257  * @brief Set peers to (non-)malicious before execution
1258  *
1259  * Of signature #PreTest
1260  *
1261  * @param rps_peer the peer to set (non-) malicious
1262  * @param h the handle to the service
1263  */
1264 static void
1265 mal_pre (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
1266 {
1267   #ifdef ENABLE_MALICIOUS
1268   uint32_t num_mal_peers;
1269
1270   GNUNET_assert ( (1 >= portion) &&
1271                   (0 <  portion) );
1272   num_mal_peers = round (portion * num_peers);
1273
1274   if (rps_peer->index < num_mal_peers)
1275   {
1276     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1277                 "%u. peer [%s] of %" PRIu32 " malicious peers turning malicious\n",
1278                 rps_peer->index,
1279                 GNUNET_i2s (rps_peer->peer_id),
1280                 num_mal_peers);
1281
1282     GNUNET_RPS_act_malicious (h, mal_type, num_mal_peers,
1283                               rps_peer_ids, target_peer);
1284   }
1285   #endif /* ENABLE_MALICIOUS */
1286 }
1287
1288 static void
1289 mal_cb (struct RPSPeer *rps_peer)
1290 {
1291   uint32_t num_mal_peers;
1292
1293   if (GNUNET_YES == in_shutdown)
1294   {
1295     return;
1296   }
1297
1298   #ifdef ENABLE_MALICIOUS
1299   GNUNET_assert ( (1 >= portion) &&
1300                   (0 <  portion) );
1301   num_mal_peers = round (portion * num_peers);
1302
1303   if (rps_peer->index >= num_mal_peers)
1304   { /* It's useless to ask a malicious peer about a random sample -
1305        it's not sampling */
1306     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
1307                                   seed_peers, rps_peer);
1308     schedule_missing_requests (rps_peer);
1309   }
1310   #endif /* ENABLE_MALICIOUS */
1311 }
1312
1313
1314 /***********************************
1315  * SINGLE_REQUEST
1316 ***********************************/
1317 static void
1318 single_req_cb (struct RPSPeer *rps_peer)
1319 {
1320   if (GNUNET_YES == in_shutdown)
1321   {
1322     return;
1323   }
1324
1325   schedule_missing_requests (rps_peer);
1326 }
1327
1328 /***********************************
1329  * DELAYED_REQUESTS
1330 ***********************************/
1331 static void
1332 delay_req_cb (struct RPSPeer *rps_peer)
1333 {
1334   if (GNUNET_YES == in_shutdown)
1335   {
1336     return;
1337   }
1338
1339   schedule_missing_requests (rps_peer);
1340 }
1341
1342 /***********************************
1343  * SEED
1344 ***********************************/
1345 static void
1346 seed_cb (struct RPSPeer *rps_peer)
1347 {
1348   if (GNUNET_YES == in_shutdown)
1349   {
1350     return;
1351   }
1352
1353   GNUNET_SCHEDULER_add_delayed (
1354       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
1355       seed_peers, rps_peer);
1356 }
1357
1358 /***********************************
1359  * SEED_BIG
1360 ***********************************/
1361 static void
1362 seed_big_cb (struct RPSPeer *rps_peer)
1363 {
1364   if (GNUNET_YES == in_shutdown)
1365   {
1366     return;
1367   }
1368
1369   // TODO test seeding > GNUNET_MAX_MESSAGE_SIZE peers
1370   GNUNET_SCHEDULER_add_delayed (
1371       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
1372       seed_peers_big, rps_peer);
1373 }
1374
1375 /***********************************
1376  * SINGLE_PEER_SEED
1377 ***********************************/
1378 static void
1379 single_peer_seed_cb (struct RPSPeer *rps_peer)
1380 {
1381   // TODO
1382 }
1383
1384 /***********************************
1385  * SEED_REQUEST
1386 ***********************************/
1387 static void
1388 seed_req_cb (struct RPSPeer *rps_peer)
1389 {
1390   if (GNUNET_YES == in_shutdown)
1391   {
1392     return;
1393   }
1394
1395   GNUNET_SCHEDULER_add_delayed (
1396       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
1397       seed_peers, rps_peer);
1398   schedule_missing_requests (rps_peer);
1399 }
1400
1401 //TODO start big mal
1402
1403 /***********************************
1404  * REQUEST_CANCEL
1405 ***********************************/
1406 static void
1407 req_cancel_cb (struct RPSPeer *rps_peer)
1408 {
1409   if (GNUNET_YES == in_shutdown)
1410   {
1411     return;
1412   }
1413
1414   schedule_missing_requests (rps_peer);
1415   GNUNET_SCHEDULER_add_delayed (
1416       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
1417                                      (cur_test_run.request_interval + 1)),
1418       cancel_request_cb, rps_peer);
1419 }
1420
1421 /***********************************
1422  * CHURN
1423 ***********************************/
1424
1425 static void
1426 churn (void *cls);
1427
1428 /**
1429  * @brief Starts churn
1430  *
1431  * Has signature of #MainTest
1432  *
1433  * This is not implemented too nicely as this is called for each peer, but we
1434  * only need to call it once. (Yes we check that we only schedule the task
1435  * once.)
1436  *
1437  * @param rps_peer The peer it's called for
1438  */
1439 static void
1440 churn_test_cb (struct RPSPeer *rps_peer)
1441 {
1442   if (GNUNET_YES == in_shutdown)
1443   {
1444     return;
1445   }
1446
1447   /* Start churn */
1448   if (HAVE_CHURN == cur_test_run.have_churn && NULL == churn_task)
1449   {
1450     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1451                 "Starting churn task\n");
1452     churn_task = GNUNET_SCHEDULER_add_delayed (
1453           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
1454           churn,
1455           NULL);
1456   } else {
1457     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1458                 "Not starting churn task\n");
1459   }
1460
1461   schedule_missing_requests (rps_peer);
1462 }
1463
1464 /***********************************
1465  * PROFILER
1466 ***********************************/
1467
1468 /**
1469  * Callback to be called when RPS service is started or stopped at peers
1470  *
1471  * @param cls NULL
1472  * @param op the operation handle
1473  * @param emsg NULL on success; otherwise an error description
1474  */
1475 static void
1476 churn_cb (void *cls,
1477           struct GNUNET_TESTBED_Operation *op,
1478           const char *emsg)
1479 {
1480   // FIXME
1481   struct OpListEntry *entry = cls;
1482
1483   if (GNUNET_YES == in_shutdown)
1484   {
1485     return;
1486   }
1487
1488   GNUNET_TESTBED_operation_done (entry->op);
1489   if (NULL != emsg)
1490   {
1491     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop RPS at a peer\n");
1492     GNUNET_SCHEDULER_shutdown ();
1493     return;
1494   }
1495   GNUNET_assert (0 != entry->delta);
1496
1497   num_peers_online += entry->delta;
1498
1499   if (PEER_GO_OFFLINE == entry->delta)
1500   { /* Peer hopefully just went offline */
1501     if (GNUNET_YES != rps_peers[entry->index].online)
1502     {
1503       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1504                   "peer %s was expected to go offline but is still marked as online\n",
1505                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1506       GNUNET_break (0);
1507     }
1508     else
1509     {
1510       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1511                   "peer %s probably went offline as expected\n",
1512                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1513     }
1514     rps_peers[entry->index].online = GNUNET_NO;
1515   }
1516
1517   else if (PEER_GO_ONLINE < entry->delta)
1518   { /* Peer hopefully just went online */
1519     if (GNUNET_NO != rps_peers[entry->index].online)
1520     {
1521       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1522                   "peer %s was expected to go online but is still marked as offline\n",
1523                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1524       GNUNET_break (0);
1525     }
1526     else
1527     {
1528       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1529                   "peer %s probably went online as expected\n",
1530                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1531       if (NULL != cur_test_run.pre_test)
1532       {
1533         cur_test_run.pre_test (&rps_peers[entry->index],
1534             rps_peers[entry->index].rps_handle);
1535         schedule_missing_requests (&rps_peers[entry->index]);
1536       }
1537     }
1538     rps_peers[entry->index].online = GNUNET_YES;
1539   }
1540   else
1541   {
1542     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1543         "Invalid value for delta: %i\n", entry->delta);
1544     GNUNET_break (0);
1545   }
1546
1547   GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
1548   rps_peers[entry->index].entry_op_manage = NULL;
1549   GNUNET_free (entry);
1550   //if (num_peers_in_round[current_round] == peers_running)
1551   //  run_round ();
1552 }
1553
1554 /**
1555  * @brief Set the rps-service up or down for a specific peer
1556  *
1557  * @param i index of action
1558  * @param j index of peer
1559  * @param delta (#PEER_ONLINE_DELTA) down (-1) or up (1)
1560  * @param prob_go_on_off the probability of the action
1561  */
1562 static void
1563 manage_service_wrapper (unsigned int i, unsigned int j,
1564                         enum PEER_ONLINE_DELTA delta,
1565                         double prob_go_on_off)
1566 {
1567   struct OpListEntry *entry = NULL;
1568   uint32_t prob;
1569
1570   /* make sure that management operation is not already scheduled */
1571   if (NULL != rps_peers[j].entry_op_manage)
1572   {
1573     return;
1574   }
1575
1576   prob = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
1577                                    UINT32_MAX);
1578   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1579               "%u. selected peer (%u: %s) is %s.\n",
1580               i,
1581               j,
1582               GNUNET_i2s (rps_peers[j].peer_id),
1583               (PEER_GO_ONLINE == delta) ? "online" : "offline");
1584   if (prob < prob_go_on_off * UINT32_MAX)
1585   {
1586     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1587                 "%s goes %s\n",
1588                 GNUNET_i2s (rps_peers[j].peer_id),
1589                 (PEER_GO_OFFLINE == delta) ? "offline" : "online");
1590
1591     if (PEER_GO_OFFLINE == delta)
1592       cancel_pending_req_rep (&rps_peers[j]);
1593     entry = make_oplist_entry ();
1594     entry->delta = delta;
1595     entry->index = j;
1596     entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
1597                                                     testbed_peers[j],
1598                                                     "rps",
1599                                                     &churn_cb,
1600                                                     entry,
1601                                                     (PEER_GO_OFFLINE == delta) ? 0 : 1);
1602     rps_peers[j].entry_op_manage = entry;
1603   }
1604 }
1605
1606
1607 static void
1608 churn (void *cls)
1609 {
1610   unsigned int i;
1611   unsigned int j;
1612   double portion_online;
1613   unsigned int *permut;
1614   double prob_go_offline;
1615   double portion_go_online;
1616   double portion_go_offline;
1617
1618   if (GNUNET_YES == in_shutdown)
1619   {
1620     return;
1621   }
1622   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1623               "Churn function executing\n");
1624
1625   churn_task = NULL; /* Should be invalid by now */
1626
1627   /* Compute the probability for an online peer to go offline
1628    * this round */
1629   portion_online = num_peers_online * 1.0 / num_peers;
1630   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1631               "Portion online: %f\n",
1632               portion_online);
1633   portion_go_online = ((1 - portion_online) * .5 * .66);
1634   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1635               "Portion that should go online: %f\n",
1636               portion_go_online);
1637   portion_go_offline = (portion_online + portion_go_online) - .75;
1638   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1639               "Portion that probably goes offline: %f\n",
1640               portion_go_offline);
1641   prob_go_offline = portion_go_offline / (portion_online * .5);
1642   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1643               "Probability of a selected online peer to go offline: %f\n",
1644               prob_go_offline);
1645
1646   permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
1647                                          (unsigned int) num_peers);
1648
1649   /* Go over 50% randomly chosen peers */
1650   for (i = 0; i < .5 * num_peers; i++)
1651   {
1652     j = permut[i];
1653
1654     /* If online, shut down with certain probability */
1655     if (GNUNET_YES == rps_peers[j].online)
1656     {
1657       manage_service_wrapper (i, j, -1, prob_go_offline);
1658     }
1659
1660     /* If offline, restart with certain probability */
1661     else if (GNUNET_NO == rps_peers[j].online)
1662     {
1663       manage_service_wrapper (i, j, 1, 0.66);
1664     }
1665   }
1666
1667   GNUNET_free (permut);
1668
1669   churn_task = GNUNET_SCHEDULER_add_delayed (
1670         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
1671         churn,
1672         NULL);
1673 }
1674
1675
1676 /**
1677  * Initialise given RPSPeer
1678  */
1679 static void profiler_init_peer (struct RPSPeer *rps_peer)
1680 {
1681   if (num_peers - 1 == rps_peer->index)
1682     rps_peer->num_ids_to_request = cur_test_run.num_requests;
1683 }
1684
1685
1686 /**
1687  * Callback to call on receipt of a reply
1688  *
1689  * @param cls closure
1690  * @param n number of peers
1691  * @param recv_peers the received peers
1692  */
1693 static void
1694 profiler_reply_handle (void *cls,
1695                       uint64_t n,
1696                       const struct GNUNET_PeerIdentity *recv_peers)
1697 {
1698   struct RPSPeer *rps_peer;
1699   struct RPSPeer *rcv_rps_peer;
1700   char *file_name;
1701   char *file_name_dh;
1702   unsigned int i;
1703   struct PendingReply *pending_rep = (struct PendingReply *) cls;
1704
1705   rps_peer = pending_rep->rps_peer;
1706   file_name = "/tmp/rps/received_ids";
1707   file_name_dh = "/tmp/rps/diehard_input";
1708   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1709               "[%s] got %" PRIu64 " peers:\n",
1710               GNUNET_i2s (rps_peer->peer_id),
1711               n);
1712   for (i = 0; i < n; i++)
1713   {
1714     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1715                 "%u: %s\n",
1716                 i,
1717                 GNUNET_i2s (&recv_peers[i]));
1718     tofile (file_name,
1719              "%s\n",
1720              GNUNET_i2s_full (&recv_peers[i]));
1721     rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, &recv_peers[i]);
1722     GNUNET_assert (NULL != rcv_rps_peer);
1723     tofile (file_name_dh,
1724              "%" PRIu32 "\n",
1725              (uint32_t) rcv_rps_peer->index);
1726   }
1727   default_reply_handle (cls, n, recv_peers);
1728 }
1729
1730
1731 static void
1732 profiler_cb (struct RPSPeer *rps_peer)
1733 {
1734   if (GNUNET_YES == in_shutdown)
1735   {
1736     return;
1737   }
1738
1739   /* Start churn */
1740   if (HAVE_CHURN == cur_test_run.have_churn && NULL == churn_task)
1741   {
1742     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1743                 "Starting churn task\n");
1744     churn_task = GNUNET_SCHEDULER_add_delayed (
1745           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
1746           churn,
1747           NULL);
1748   } else {
1749     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1750                 "Not starting churn task\n");
1751   }
1752
1753   /* Only request peer ids at one peer.
1754    * (It's the before-last because last one is target of the focussed attack.)
1755    */
1756   if (eval_peer == rps_peer)
1757     schedule_missing_requests (rps_peer);
1758 }
1759
1760 /**
1761  * Function called from #profiler_eval with a filename.
1762  *
1763  * @param cls closure
1764  * @param filename complete filename (absolute path)
1765  * @return #GNUNET_OK to continue to iterate,
1766  *  #GNUNET_NO to stop iteration with no error,
1767  *  #GNUNET_SYSERR to abort iteration with error!
1768  */
1769 int
1770 file_name_cb (void *cls, const char *filename)
1771 {
1772   if (NULL != strstr (filename, "sampler_el"))
1773   {
1774     struct RPS_SamplerElement *s_elem;
1775     struct GNUNET_CRYPTO_AuthKey auth_key;
1776     const char *key_char;
1777     uint32_t i;
1778
1779     key_char = filename + 20; /* Length of "/tmp/rps/sampler_el-" */
1780     tofile (filename, "--------------------------\n");
1781
1782     auth_key = string_to_auth_key (key_char);
1783     s_elem = RPS_sampler_elem_create ();
1784     RPS_sampler_elem_set (s_elem, auth_key);
1785
1786     for (i = 0; i < num_peers; i++)
1787     {
1788       RPS_sampler_elem_next (s_elem, &rps_peer_ids[i]);
1789     }
1790     RPS_sampler_elem_destroy (s_elem);
1791   }
1792   return GNUNET_OK;
1793 }
1794
1795 /**
1796  * This is run after the test finished.
1797  *
1798  * Compute all perfect samples.
1799  */
1800 int
1801 profiler_eval (void)
1802 {
1803   /* Compute perfect sample for each sampler element */
1804   if (-1 == GNUNET_DISK_directory_scan ("/tmp/rps/", file_name_cb, NULL))
1805   {
1806     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Scan of directory failed\n");
1807   }
1808
1809   return evaluate ();
1810 }
1811
1812 /**
1813  * @brief Try to ensure that `/tmp/rps` exists.
1814  *
1815  * @return #GNUNET_YES on success
1816  *         #GNUNET_SYSERR on failure
1817  */
1818 static int ensure_folder_exist (void)
1819 {
1820   if (GNUNET_NO == GNUNET_DISK_directory_test ("/tmp/rps/", GNUNET_NO))
1821   {
1822     GNUNET_DISK_directory_create ("/tmp/rps");
1823   }
1824   if (GNUNET_YES != GNUNET_DISK_directory_test ("/tmp/rps/", GNUNET_NO))
1825   {
1826     return GNUNET_SYSERR;
1827   }
1828   return GNUNET_YES;
1829 }
1830
1831 static const char *
1832 store_prefix_file_name (struct RPSPeer *rps_peer, const char *prefix)
1833 {
1834   unsigned int len_file_name;
1835   unsigned int out_size;
1836   char *file_name;
1837   const char *pid_long;
1838
1839   if (GNUNET_SYSERR == ensure_folder_exist()) return NULL;
1840   pid_long = GNUNET_i2s_full (rps_peer->peer_id);
1841   len_file_name = (strlen (prefix) +
1842                    strlen (pid_long) +
1843                    11)
1844                      * sizeof (char);
1845   file_name = GNUNET_malloc (len_file_name);
1846   out_size = GNUNET_snprintf (file_name,
1847                               len_file_name,
1848                               "/tmp/rps/%s-%s",
1849                               prefix,
1850                               pid_long);
1851   if (len_file_name < out_size ||
1852       0 > out_size)
1853   {
1854     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1855                "Failed to write string to buffer (size: %i, out_size: %i)\n",
1856                len_file_name,
1857                out_size);
1858   }
1859   return file_name;
1860 }
1861
1862 static uint32_t fac (uint32_t x)
1863 {
1864   if (1 >= x)
1865   {
1866     return x;
1867   }
1868   return x * fac (x - 1);
1869 }
1870
1871 static uint32_t binom (uint32_t n, uint32_t k)
1872 {
1873   //GNUNET_assert (n >= k);
1874   if (k > n) return 0;
1875   if (0 > n) return 0;
1876   if (0 > k) return 0;
1877   if (0 == k) return 1;
1878   return fac (n)
1879     /
1880     fac(k) * fac(n - k);
1881 }
1882
1883 /**
1884  * @brief is b in view of a?
1885  *
1886  * @param a
1887  * @param b
1888  *
1889  * @return
1890  */
1891 static int is_in_view (uint32_t a, uint32_t b)
1892 {
1893   uint32_t i;
1894   for (i = 0; i < rps_peers[a].cur_view_count; i++)
1895   {
1896     if (0 == memcmp (rps_peers[b].peer_id,
1897           &rps_peers[a].cur_view[i],
1898           sizeof (struct GNUNET_PeerIdentity)))
1899     {
1900       return GNUNET_YES;
1901     }
1902   }
1903   return GNUNET_NO;
1904 }
1905
1906 static uint32_t get_idx_of_pid (const struct GNUNET_PeerIdentity *pid)
1907 {
1908   uint32_t i;
1909
1910   for (i = 0; i < num_peers; i++)
1911   {
1912     if (0 == memcmp (pid,
1913           rps_peers[i].peer_id,
1914           sizeof (struct GNUNET_PeerIdentity)))
1915     {
1916       return i;
1917     }
1918   }
1919   //return 0; /* Should not happen - make compiler happy */
1920   GNUNET_assert (0);
1921 }
1922
1923 /**
1924  * @brief Counts number of peers in view of a that have b in their view
1925  *
1926  * @param a
1927  * @param uint32_tb
1928  *
1929  * @return
1930  */
1931 static uint32_t count_containing_views (uint32_t a, uint32_t b)
1932 {
1933   uint32_t i;
1934   uint32_t peer_idx;
1935   uint32_t count = 0;
1936
1937   for (i = 0; i < rps_peers[a].cur_view_count; i++)
1938   {
1939     peer_idx = get_idx_of_pid (&rps_peers[a].cur_view[i]);
1940     if (GNUNET_YES == is_in_view (peer_idx, b))
1941     {
1942       count++;
1943     }
1944   }
1945   return count;
1946 }
1947
1948 /**
1949  * @brief Computes the probability for each other peer to be selected by the
1950  * sampling process based on the views of all peers
1951  *
1952  * @param peer_idx index of the peer that is about to sample
1953  */
1954 static void compute_probabilities (uint32_t peer_idx)
1955 {
1956   //double probs[num_peers] = { 0 };
1957   double probs[num_peers];
1958   size_t probs_as_str_size = (num_peers * 6 + 1) * sizeof (char);
1959   char *probs_as_str = GNUNET_malloc (probs_as_str_size);
1960   char *probs_as_str_cpy;
1961   uint32_t i;
1962   double prob_push;
1963   double prob_pull;
1964   uint32_t view_size;
1965   uint32_t cont_views;
1966   int tmp;
1967   uint32_t count_non_zero_prob = 0;
1968
1969   /* Firstly without knowledge of old views */
1970   for (i = 0; i < num_peers; i++)
1971   {
1972     view_size = rps_peers[i].cur_view_count;
1973     /* For peer i the probability of being sampled is
1974      * evenly distributed among all possibly observed peers. */
1975     /* We could have observed a peer in three cases:
1976      *   1. peer sent a push
1977      *   2. peer was contained in a pull reply
1978      *   3. peer was in history (sampler) - ignored for now */
1979     /* 1. Probability of having received a push from peer i */
1980     if ((GNUNET_YES == is_in_view (i, peer_idx)) &&
1981         (1 <= (0.45 * view_size)))
1982     {
1983       prob_push = 1.0 * binom (0.45 * view_size, 1)
1984         /
1985         binom (view_size, 0.45 * view_size);
1986     } else {
1987       prob_push = 0;
1988     }
1989     /* 2. Probability of peer i being contained in pulls */
1990     view_size = rps_peers[peer_idx].cur_view_count;
1991     cont_views = count_containing_views (i, peer_idx);
1992     prob_pull = 1.0
1993       /
1994       (binom (view_size, 0.45 * view_size) -
1995        binom (view_size - cont_views, 0.45 * view_size));
1996     if (0 == cont_views) prob_pull = 0;
1997     probs[i] = prob_push + prob_pull - (prob_push * prob_pull);
1998
1999     if (0 != probs[i]) count_non_zero_prob++;
2000   }
2001   /* normalize */
2002   if (0 != count_non_zero_prob)
2003   {
2004     for (i = 0; i < num_peers; i++)
2005     {
2006       probs[i] = probs[i] * (1.0 / count_non_zero_prob);
2007     }
2008   } else {
2009     for (i = 0; i < num_peers; i++)
2010     {
2011       probs[i] = 0;
2012     }
2013   }
2014   /* str repr */
2015   for (i = 0; i < num_peers; i++)
2016   {
2017     probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
2018     tmp = GNUNET_snprintf (probs_as_str,
2019                            probs_as_str_size,
2020                            "%s %3.2f", probs_as_str_cpy, probs[i]);
2021     GNUNET_free (probs_as_str_cpy);
2022     GNUNET_assert (0 <= tmp);
2023   }
2024
2025   to_file_w_len (rps_peers[peer_idx].file_name_probs,
2026                  probs_as_str_size,
2027                  probs_as_str);
2028   GNUNET_free (probs_as_str);
2029 }
2030
2031 /**
2032  * @brief This counts the number of peers in which views a given peer occurs.
2033  *
2034  * It also stores this value in the rps peer.
2035  *
2036  * @param peer_idx the index of the peer to count the representation
2037  *
2038  * @return the number of occurrences
2039  */
2040 static uint32_t count_peer_in_views_2 (uint32_t peer_idx)
2041 {
2042   uint32_t i, j;
2043   uint32_t count = 0;
2044
2045   for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2046   {
2047     for (j = 0; j < rps_peers[i].cur_view_count; j++) /* entry in view */
2048     {
2049       if (0 == memcmp (rps_peers[peer_idx].peer_id,
2050             &rps_peers[i].cur_view[j],
2051             sizeof (struct GNUNET_PeerIdentity)))
2052       {
2053         count++;
2054         break;
2055       }
2056     }
2057   }
2058   rps_peers[peer_idx].count_in_views = count;
2059   return count;
2060 }
2061
2062 static uint32_t cumulated_view_sizes ()
2063 {
2064   uint32_t i;
2065
2066   view_sizes = 0;
2067   for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2068   {
2069     view_sizes += rps_peers[i].cur_view_count;
2070   }
2071   return view_sizes;
2072 }
2073
2074 static void count_peer_in_views (uint32_t *count_peers)
2075 {
2076   uint32_t i, j;
2077
2078   for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2079   {
2080     for (j = 0; j < rps_peers[i].cur_view_count; j++) /* entry in view */
2081     {
2082       if (0 == memcmp (rps_peers[i].peer_id,
2083             &rps_peers[i].cur_view[j],
2084             sizeof (struct GNUNET_PeerIdentity)))
2085       {
2086         count_peers[i]++;
2087       }
2088     }
2089   }
2090 }
2091
2092 void compute_diversity ()
2093 {
2094   uint32_t i;
2095   /* ith entry represents the numer of occurrences in other peer's views */
2096   uint32_t *count_peers = GNUNET_new_array (num_peers, uint32_t);
2097   uint32_t views_total_size;
2098   double expected;
2099   /* deviation from expected number of peers */
2100   double *deviation = GNUNET_new_array (num_peers, double);
2101
2102   views_total_size = 0;
2103   expected = 0;
2104
2105   /* For each peer count its representation in other peer's views*/
2106   for (i = 0; i < num_peers; i++) /* Peer to count */
2107   {
2108     views_total_size += rps_peers[i].cur_view_count;
2109     count_peer_in_views (count_peers);
2110     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2111                "Counted representation of %" PRIu32 "th peer [%s]: %" PRIu32"\n",
2112                i,
2113                GNUNET_i2s (rps_peers[i].peer_id),
2114                count_peers[i]);
2115   }
2116
2117   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2118              "size of all views combined: %" PRIu32 "\n",
2119              views_total_size);
2120   expected = ((double) 1/num_peers) * views_total_size;
2121   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2122              "Expected number of occurrences of each peer in all views: %f\n",
2123              expected);
2124   for (i = 0; i < num_peers; i++) /* Peer to count */
2125   {
2126     deviation[i] = expected - count_peers[i];
2127     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2128                "Deviation from expectation: %f\n", deviation[i]);
2129   }
2130   GNUNET_free (count_peers);
2131   GNUNET_free (deviation);
2132 }
2133
2134 void print_view_sizes()
2135 {
2136   uint32_t i;
2137
2138   for (i = 0; i < num_peers; i++) /* Peer to count */
2139   {
2140     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2141                "View size of %" PRIu32 ". [%s] is %" PRIu32 "\n",
2142                i,
2143                GNUNET_i2s (rps_peers[i].peer_id),
2144                rps_peers[i].cur_view_count);
2145   }
2146 }
2147
2148 void all_views_updated_cb()
2149 {
2150   compute_diversity();
2151   print_view_sizes();
2152 }
2153
2154 void view_update_cb (void *cls,
2155                      uint64_t view_size,
2156                      const struct GNUNET_PeerIdentity *peers)
2157 {
2158   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2159               "View was updated (%" PRIu64 ")\n", view_size);
2160   struct RPSPeer *rps_peer = (struct RPSPeer *) cls;
2161   to_file ("/tmp/rps/view_sizes.txt",
2162          "%" PRIu64 " %" PRIu32 "",
2163          rps_peer->index,
2164          view_size);
2165   for (int i = 0; i < view_size; i++)
2166   {
2167     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2168                "\t%s\n", GNUNET_i2s (&peers[i]));
2169   }
2170   GNUNET_array_grow (rps_peer->cur_view,
2171                      rps_peer->cur_view_count,
2172                      view_size);
2173   //*rps_peer->cur_view = *peers;
2174   memcpy (rps_peer->cur_view,
2175           peers,
2176           view_size * sizeof (struct GNUNET_PeerIdentity));
2177   to_file ("/tmp/rps/count_in_views.txt",
2178          "%" PRIu64 " %" PRIu32 "",
2179          rps_peer->index,
2180          count_peer_in_views_2 (rps_peer->index));
2181   cumulated_view_sizes();
2182   to_file ("/tmp/rps/repr.txt",
2183          "%" PRIu64 /* index */
2184          " %" PRIu32 /* occurrence in views */
2185          " %" PRIu32 /* view sizes */
2186          " %f" /* fraction of repr in views */
2187          " %f" /* average view size */
2188          " %f" /* prob of occurrence in view slot */
2189          " %f" "", /* exp frac of repr in views */
2190          rps_peer->index,
2191          count_peer_in_views_2 (rps_peer->index),
2192          view_sizes,
2193          count_peer_in_views_2 (rps_peer->index) / (view_size * 1.0), /* fraction of representation in views */
2194          view_sizes / (view_size * 1.0), /* average view size */
2195          1.0 /view_size, /* prob of occurrence in view slot */
2196          (1.0/view_size) * (view_sizes/view_size) /* expected fraction of repr in views */
2197          );
2198   compute_probabilities (rps_peer->index);
2199   all_views_updated_cb();
2200 }
2201
2202 static void
2203 pre_profiler (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
2204 {
2205   rps_peer->file_name_probs = store_prefix_file_name (rps_peer, "probs");
2206   GNUNET_RPS_view_request (h, 0, view_update_cb, rps_peer);
2207 }
2208
2209 void write_final_stats (void){
2210   uint32_t i;
2211
2212   for (i = 0; i < num_peers; i++)
2213   {
2214     to_file ("/tmp/rps/final_stats.dat",
2215              "%" PRIu32 " " /* index */
2216              "%s %" /* id */
2217              PRIu64 " %" /* rounds */
2218              PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" /* blocking */
2219              PRIu64 " %" PRIu64 " %" PRIu64 " %" /* issued */
2220              PRIu64 " %" PRIu64 " %" PRIu64 " %" /* sent */
2221              PRIu64 " %" PRIu64 " %" PRIu64 /* recv */,
2222              i,
2223              GNUNET_i2s (rps_peers[i].peer_id),
2224              rps_peers[i].num_rounds,
2225              rps_peers[i].num_blocks,
2226              rps_peers[i].num_blocks_many_push,
2227              rps_peers[i].num_blocks_no_push,
2228              rps_peers[i].num_blocks_no_pull,
2229              rps_peers[i].num_blocks_many_push_no_pull,
2230              rps_peers[i].num_blocks_no_push_no_pull,
2231              rps_peers[i].num_issued_push,
2232              rps_peers[i].num_issued_pull_req,
2233              rps_peers[i].num_issued_pull_rep,
2234              rps_peers[i].num_sent_push,
2235              rps_peers[i].num_sent_pull_req,
2236              rps_peers[i].num_sent_pull_rep,
2237              rps_peers[i].num_recv_push,
2238              rps_peers[i].num_recv_pull_req,
2239              rps_peers[i].num_recv_pull_rep);
2240   }
2241 }
2242
2243 /**
2244  * Continuation called by #GNUNET_STATISTICS_get() functions.
2245  *
2246  * Remembers that this specific statistics value was received for this peer.
2247  * Checks whether all peers received their statistics yet.
2248  * Issues the shutdown.
2249  *
2250  * @param cls closure
2251  * @param success #GNUNET_OK if statistics were
2252  *        successfully obtained, #GNUNET_SYSERR if not.
2253  */
2254 void
2255 post_test_shutdown_ready_cb (void *cls,
2256                              int success)
2257 {
2258   struct STATcls *stat_cls = (struct STATcls *) cls;
2259   struct RPSPeer *rps_peer = stat_cls->rps_peer;
2260   if (GNUNET_OK == success)
2261   {
2262     /* set flag that we we got the value */
2263     rps_peer->stat_collected_flags |= stat_cls->stat_type;
2264   } else {
2265     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2266         "Peer %u did not receive statistics value\n",
2267         rps_peer->index);
2268     GNUNET_free (stat_cls);
2269     GNUNET_break (0);
2270   }
2271
2272   if (NULL != rps_peer->stat_op &&
2273       GNUNET_YES == check_statistics_collect_completed_single_peer (rps_peer))
2274   {
2275     GNUNET_TESTBED_operation_done (rps_peer->stat_op);
2276   }
2277
2278   write_final_stats ();
2279   if (GNUNET_YES == check_statistics_collect_completed())
2280   {
2281     //write_final_stats ();
2282     GNUNET_free (stat_cls);
2283     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2284         "Shutting down\n");
2285     GNUNET_SCHEDULER_shutdown ();
2286   } else {
2287     GNUNET_free (stat_cls);
2288   }
2289 }
2290
2291 /**
2292  * @brief Converts string representation to the corresponding #STAT_TYPE enum.
2293  *
2294  * @param stat_str string representation of statistics specifier
2295  *
2296  * @return corresponding enum
2297  */
2298 enum STAT_TYPE stat_str_2_type (const char *stat_str)
2299 {
2300   if (0 == strncmp ("# rounds blocked - no pull replies", stat_str, strlen ("# rounds blocked - no pull replies")))
2301   {
2302     return STAT_TYPE_BLOCKS_NO_PULL;
2303   }
2304   else if (0 == strncmp ("# rounds blocked - too many pushes, no pull replies", stat_str, strlen ("# rounds blocked - too many pushes, no pull replies")))
2305   {
2306     return STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL;
2307   }
2308   else if (0 == strncmp ("# rounds blocked - too many pushes", stat_str, strlen ("# rounds blocked - too many pushes")))
2309   {
2310     return STAT_TYPE_BLOCKS_MANY_PUSH;
2311   }
2312   else if (0 == strncmp ("# rounds blocked - no pushes, no pull replies", stat_str, strlen ("# rounds blocked - no pushes, no pull replies")))
2313   {
2314     return STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL;
2315   }
2316   else if (0 == strncmp ("# rounds blocked - no pushes", stat_str, strlen ("# rounds blocked - no pushes")))
2317   {
2318     return STAT_TYPE_BLOCKS_NO_PUSH;
2319   }
2320   else if (0 == strncmp ("# rounds blocked", stat_str, strlen ("# rounds blocked")))
2321   {
2322     return STAT_TYPE_BLOCKS;
2323   }
2324   else if (0 == strncmp ("# rounds", stat_str, strlen ("# rounds")))
2325   {
2326     return STAT_TYPE_ROUNDS;
2327   }
2328   else if (0 == strncmp ("# push send issued", stat_str, strlen ("# push send issued")))
2329   {
2330     return STAT_TYPE_ISSUED_PUSH_SEND;
2331   }
2332   else if (0 == strncmp ("# pull request send issued", stat_str, strlen ("# pull request send issued")))
2333   {
2334     return STAT_TYPE_ISSUED_PULL_REQ;
2335   }
2336   else if (0 == strncmp ("# pull reply send issued", stat_str, strlen ("# pull reply send issued")))
2337   {
2338     return STAT_TYPE_ISSUED_PULL_REP;
2339   }
2340   else if (0 == strncmp ("# pushes sent", stat_str, strlen ("# pushes sent")))
2341   {
2342     return STAT_TYPE_SENT_PUSH_SEND;
2343   }
2344   else if (0 == strncmp ("# pull requests sent", stat_str, strlen ("# pull requests sent")))
2345   {
2346     return STAT_TYPE_SENT_PULL_REQ;
2347   }
2348   else if (0 == strncmp ("# pull replys sent", stat_str, strlen ("# pull replys sent")))
2349   {
2350     return STAT_TYPE_SENT_PULL_REP;
2351   }
2352   else if (0 == strncmp ("# push message received", stat_str, strlen ("# push message received")))
2353   {
2354     return STAT_TYPE_RECV_PUSH_SEND;
2355   }
2356   else if (0 == strncmp ("# pull request message received", stat_str, strlen ("# pull request message received")))
2357   {
2358     return STAT_TYPE_RECV_PULL_REQ;
2359   }
2360   else if (0 == strncmp ("# pull reply messages received", stat_str, strlen ("# pull reply messages received")))
2361   {
2362     return STAT_TYPE_RECV_PULL_REP;
2363   }
2364   return STAT_TYPE_MAX;
2365 }
2366
2367
2368 /**
2369  * @brief Converts #STAT_TYPE enum to the equivalent string representation that
2370  * is stored with the statistics service.
2371  *
2372  * @param stat_type #STAT_TYPE enum
2373  *
2374  * @return string representation that matches statistics value
2375  */
2376 char* stat_type_2_str (enum STAT_TYPE stat_type)
2377 {
2378   switch (stat_type)
2379   {
2380     case STAT_TYPE_ROUNDS:
2381       return "# rounds";
2382     case STAT_TYPE_BLOCKS:
2383       return "# rounds blocked";
2384     case STAT_TYPE_BLOCKS_MANY_PUSH:
2385       return "# rounds blocked - too many pushes";
2386     case STAT_TYPE_BLOCKS_NO_PUSH:
2387       return "# rounds blocked - no pushes";
2388     case STAT_TYPE_BLOCKS_NO_PULL:
2389       return "# rounds blocked - no pull replies";
2390     case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL:
2391       return "# rounds blocked - too many pushes, no pull replies";
2392     case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL:
2393       return "# rounds blocked - no pushes, no pull replies";
2394     case STAT_TYPE_ISSUED_PUSH_SEND:
2395       return "# push send issued";
2396     case STAT_TYPE_ISSUED_PULL_REQ:
2397       return "# pull request send issued";
2398     case STAT_TYPE_ISSUED_PULL_REP:
2399       return "# pull reply send issued";
2400     case STAT_TYPE_SENT_PUSH_SEND:
2401       return "# pushes sent";
2402     case STAT_TYPE_SENT_PULL_REQ:
2403       return "# pull requests sent";
2404     case STAT_TYPE_SENT_PULL_REP:
2405       return "# pull replys sent";
2406     case STAT_TYPE_RECV_PUSH_SEND:
2407       return "# push message received";
2408     case STAT_TYPE_RECV_PULL_REQ:
2409       return "# pull request message received";
2410     case STAT_TYPE_RECV_PULL_REP:
2411       return "# pull reply messages received";
2412     case STAT_TYPE_MAX:
2413     default:
2414       return "ERROR";
2415       ;
2416   }
2417 }
2418
2419 /**
2420  * Callback function to process statistic values.
2421  *
2422  * @param cls closure
2423  * @param subsystem name of subsystem that created the statistic
2424  * @param name the name of the datum
2425  * @param value the current value
2426  * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
2427  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
2428  */
2429 int
2430 stat_iterator (void *cls,
2431                const char *subsystem,
2432                const char *name,
2433                uint64_t value,
2434                int is_persistent)
2435 {
2436   const struct STATcls *stat_cls = (const struct STATcls *) cls;
2437   struct RPSPeer *rps_peer = (struct RPSPeer *) stat_cls->rps_peer;
2438   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got stat value: %s - %" PRIu64 "\n",
2439       //stat_type_2_str (stat_cls->stat_type),
2440       name,
2441       value);
2442   to_file (rps_peer->file_name_stats,
2443           "%s: %" PRIu64 "\n",
2444           name,
2445           value);
2446   switch (stat_str_2_type (name))
2447   {
2448     case STAT_TYPE_ROUNDS:
2449       rps_peer->num_rounds = value;
2450       break;
2451     case STAT_TYPE_BLOCKS:
2452       rps_peer->num_blocks = value;
2453       break;
2454     case STAT_TYPE_BLOCKS_MANY_PUSH:
2455       rps_peer->num_blocks_many_push = value;
2456       break;
2457     case STAT_TYPE_BLOCKS_NO_PUSH:
2458       rps_peer->num_blocks_no_push = value;
2459       break;
2460     case STAT_TYPE_BLOCKS_NO_PULL:
2461       rps_peer->num_blocks_no_pull = value;
2462       break;
2463     case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL:
2464       rps_peer->num_blocks_many_push_no_pull = value;
2465       break;
2466     case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL:
2467       rps_peer->num_blocks_no_push_no_pull = value;
2468       break;
2469     case STAT_TYPE_ISSUED_PUSH_SEND:
2470       rps_peer->num_issued_push = value;
2471       break;
2472     case STAT_TYPE_ISSUED_PULL_REQ:
2473       rps_peer->num_issued_pull_req = value;
2474       break;
2475     case STAT_TYPE_ISSUED_PULL_REP:
2476       rps_peer->num_issued_pull_rep = value;
2477       break;
2478     case STAT_TYPE_SENT_PUSH_SEND:
2479       rps_peer->num_sent_push = value;
2480       break;
2481     case STAT_TYPE_SENT_PULL_REQ:
2482       rps_peer->num_sent_pull_req = value;
2483       break;
2484     case STAT_TYPE_SENT_PULL_REP:
2485       rps_peer->num_sent_pull_rep = value;
2486       break;
2487     case STAT_TYPE_RECV_PUSH_SEND:
2488       rps_peer->num_recv_push = value;
2489       break;
2490     case STAT_TYPE_RECV_PULL_REQ:
2491       rps_peer->num_recv_pull_req = value;
2492       break;
2493     case STAT_TYPE_RECV_PULL_REP:
2494       rps_peer->num_recv_pull_rep = value;
2495       break;
2496     case STAT_TYPE_MAX:
2497     default:
2498       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2499                  "Unknown statistics string: %s\n",
2500                  name);
2501       break;
2502   }
2503   return GNUNET_OK;
2504 }
2505
2506 void post_profiler (struct RPSPeer *rps_peer)
2507 {
2508   if (COLLECT_STATISTICS != cur_test_run.have_collect_statistics)
2509   {
2510     return;
2511   }
2512
2513   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2514       "Going to request statistic values with mask 0x%" PRIx32 "\n",
2515       cur_test_run.stat_collect_flags);
2516
2517   struct STATcls *stat_cls;
2518   uint32_t stat_type;
2519   for (stat_type = STAT_TYPE_ROUNDS;
2520       stat_type < STAT_TYPE_MAX;
2521       stat_type = stat_type <<1)
2522   {
2523     if (stat_type & cur_test_run.stat_collect_flags)
2524     {
2525       stat_cls = GNUNET_malloc (sizeof (struct STATcls));
2526       stat_cls->rps_peer = rps_peer;
2527       stat_cls->stat_type = stat_type;
2528       rps_peer->file_name_stats = store_prefix_file_name (rps_peer, "stats");
2529       GNUNET_STATISTICS_get (rps_peer->stats_h,
2530                              "rps",
2531                              stat_type_2_str (stat_type),
2532                              post_test_shutdown_ready_cb,
2533                              stat_iterator,
2534                              (struct STATcls *) stat_cls);
2535       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2536           "Requested statistics for %s (peer %" PRIu32 ")\n",
2537           stat_type_2_str (stat_type),
2538           rps_peer->index);
2539     }
2540   }
2541 }
2542
2543
2544 /***********************************************************************
2545  * /Definition of tests
2546 ***********************************************************************/
2547
2548
2549 /**
2550  * Actual "main" function for the testcase.
2551  *
2552  * @param cls closure
2553  * @param h the run handle
2554  * @param n_peers number of peers in 'peers'
2555  * @param peers handle to peers run in the testbed
2556  * @param links_succeeded the number of overlay link connection attempts that
2557  *          succeeded
2558  * @param links_failed the number of overlay link connection attempts that
2559  *          failed
2560  */
2561 static void
2562 run (void *cls,
2563      struct GNUNET_TESTBED_RunHandle *h,
2564      unsigned int n_peers,
2565      struct GNUNET_TESTBED_Peer **peers,
2566      unsigned int links_succeeded,
2567      unsigned int links_failed)
2568 {
2569   unsigned int i;
2570   struct OpListEntry *entry;
2571
2572   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
2573
2574   /* Check whether we timed out */
2575   if (n_peers != num_peers ||
2576       NULL == peers ||
2577       0 == links_succeeded)
2578   {
2579     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Going down due to args (eg. timeout)\n");
2580     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
2581     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n", num_peers);
2582     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
2583     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n", links_succeeded);
2584     GNUNET_SCHEDULER_shutdown ();
2585     return;
2586   }
2587
2588
2589   /* Initialize peers */
2590   testbed_peers = peers;
2591   num_peers_online = 0;
2592   for (i = 0; i < num_peers; i++)
2593   {
2594     entry = make_oplist_entry ();
2595     entry->index = i;
2596     rps_peers[i].index = i;
2597     if (NULL != cur_test_run.init_peer)
2598       cur_test_run.init_peer (&rps_peers[i]);
2599     if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
2600     {
2601       rps_peers->cur_view_count = 0;
2602       rps_peers->cur_view = NULL;
2603     }
2604     entry->op = GNUNET_TESTBED_peer_get_information (peers[i],
2605                                                      GNUNET_TESTBED_PIT_IDENTITY,
2606                                                      &info_cb,
2607                                                      entry);
2608   }
2609
2610   /* Bring peers up */
2611   GNUNET_assert (num_peers == n_peers);
2612   for (i = 0; i < n_peers; i++)
2613   {
2614     rps_peers[i].index = i;
2615     rps_peers[i].op =
2616       GNUNET_TESTBED_service_connect (&rps_peers[i],
2617                                       peers[i],
2618                                       "rps",
2619                                       &rps_connect_complete_cb,
2620                                       &rps_peers[i],
2621                                       &rps_connect_adapter,
2622                                       &rps_disconnect_adapter,
2623                                       &rps_peers[i]);
2624     /* Connect all peers to statistics service */
2625     if (COLLECT_STATISTICS == cur_test_run.have_collect_statistics)
2626     {
2627       rps_peers[i].stat_op =
2628         GNUNET_TESTBED_service_connect (NULL,
2629                                         peers[i],
2630                                         "statistics",
2631                                         stat_complete_cb,
2632                                         &rps_peers[i],
2633                                         &stat_connect_adapter,
2634                                         &stat_disconnect_adapter,
2635                                         &rps_peers[i]);
2636     }
2637   }
2638
2639   if (NULL != churn_task)
2640     GNUNET_SCHEDULER_cancel (churn_task);
2641   shutdown_task = GNUNET_SCHEDULER_add_delayed (timeout, &shutdown_op, NULL);
2642 }
2643
2644
2645 /**
2646  * Entry point for the testcase, sets up the testbed.
2647  *
2648  * @param argc unused
2649  * @param argv unused
2650  * @return 0 on success
2651  */
2652 int
2653 main (int argc, char *argv[])
2654 {
2655   int ret_value;
2656
2657   /* Defaults for tests */
2658   num_peers = 5;
2659   cur_test_run.name = "test-rps-default";
2660   cur_test_run.init_peer = default_init_peer;
2661   cur_test_run.pre_test = NULL;
2662   cur_test_run.reply_handle = default_reply_handle;
2663   cur_test_run.eval_cb = default_eval_cb;
2664   cur_test_run.post_test = NULL;
2665   cur_test_run.have_churn = HAVE_CHURN;
2666   cur_test_run.have_collect_statistics = NO_COLLECT_STATISTICS;
2667   cur_test_run.stat_collect_flags = 0;
2668   cur_test_run.have_collect_view = NO_COLLECT_VIEW;
2669   churn_task = NULL;
2670   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
2671
2672   if (strstr (argv[0], "malicious") != NULL)
2673   {
2674     cur_test_run.pre_test = mal_pre;
2675     cur_test_run.main_test = mal_cb;
2676     cur_test_run.init_peer = mal_init_peer;
2677
2678     if (strstr (argv[0], "_1") != NULL)
2679     {
2680       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 1\n");
2681       cur_test_run.name = "test-rps-malicious_1";
2682       mal_type = 1;
2683     }
2684     else if (strstr (argv[0], "_2") != NULL)
2685     {
2686       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 2\n");
2687       cur_test_run.name = "test-rps-malicious_2";
2688       mal_type = 2;
2689     }
2690     else if (strstr (argv[0], "_3") != NULL)
2691     {
2692       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 3\n");
2693       cur_test_run.name = "test-rps-malicious_3";
2694       mal_type = 3;
2695     }
2696   }
2697
2698   else if (strstr (argv[0], "_single_req") != NULL)
2699   {
2700     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test single request\n");
2701     cur_test_run.name = "test-rps-single-req";
2702     cur_test_run.main_test = single_req_cb;
2703     cur_test_run.have_churn = HAVE_NO_CHURN;
2704   }
2705
2706   else if (strstr (argv[0], "_delayed_reqs") != NULL)
2707   {
2708     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test delayed requests\n");
2709     cur_test_run.name = "test-rps-delayed-reqs";
2710     cur_test_run.main_test = delay_req_cb;
2711     cur_test_run.have_churn = HAVE_NO_CHURN;
2712   }
2713
2714   else if (strstr (argv[0], "_seed_big") != NULL)
2715   {
2716     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding (num_peers > GNUNET_MAX_MESSAGE_SIZE)\n");
2717     num_peers = 1;
2718     cur_test_run.name = "test-rps-seed-big";
2719     cur_test_run.main_test = seed_big_cb;
2720     cur_test_run.eval_cb = no_eval;
2721     cur_test_run.have_churn = HAVE_NO_CHURN;
2722     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
2723   }
2724
2725   else if (strstr (argv[0], "_single_peer_seed") != NULL)
2726   {
2727     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on a single peer\n");
2728     cur_test_run.name = "test-rps-single-peer-seed";
2729     cur_test_run.main_test = single_peer_seed_cb;
2730     cur_test_run.have_churn = HAVE_NO_CHURN;
2731   }
2732
2733   else if (strstr (argv[0], "_seed_request") != NULL)
2734   {
2735     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on multiple peers\n");
2736     cur_test_run.name = "test-rps-seed-request";
2737     cur_test_run.main_test = seed_req_cb;
2738     cur_test_run.have_churn = HAVE_NO_CHURN;
2739   }
2740
2741   else if (strstr (argv[0], "_seed") != NULL)
2742   {
2743     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding\n");
2744     cur_test_run.name = "test-rps-seed";
2745     cur_test_run.main_test = seed_cb;
2746     cur_test_run.eval_cb = no_eval;
2747     cur_test_run.have_churn = HAVE_NO_CHURN;
2748   }
2749
2750   else if (strstr (argv[0], "_req_cancel") != NULL)
2751   {
2752     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test cancelling a request\n");
2753     cur_test_run.name = "test-rps-req-cancel";
2754     num_peers = 1;
2755     cur_test_run.main_test = req_cancel_cb;
2756     cur_test_run.eval_cb = no_eval;
2757     cur_test_run.have_churn = HAVE_NO_CHURN;
2758     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
2759   }
2760
2761   else if (strstr (argv[0], "_churn") != NULL)
2762   {
2763     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test churn\n");
2764     cur_test_run.name = "test-rps-churn";
2765     num_peers = 5;
2766     cur_test_run.init_peer = default_init_peer;
2767     cur_test_run.main_test = churn_test_cb;
2768     cur_test_run.reply_handle = default_reply_handle;
2769     cur_test_run.eval_cb = default_eval_cb;
2770     cur_test_run.have_churn = HAVE_CHURN;
2771     cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
2772     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
2773   }
2774
2775   else if (strstr (argv[0], "profiler") != NULL)
2776   {
2777     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "This is the profiler\n");
2778     cur_test_run.name = "test-rps-profiler";
2779     num_peers = 10;
2780     mal_type = 3;
2781     cur_test_run.init_peer = profiler_init_peer;
2782     //cur_test_run.pre_test = mal_pre;
2783     cur_test_run.pre_test = pre_profiler;
2784     cur_test_run.main_test = profiler_cb;
2785     cur_test_run.reply_handle = profiler_reply_handle;
2786     cur_test_run.eval_cb = profiler_eval;
2787     cur_test_run.post_test = post_profiler;
2788     cur_test_run.request_interval = 2;
2789     cur_test_run.num_requests = 5;
2790     cur_test_run.have_churn = HAVE_CHURN;
2791     cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
2792     cur_test_run.have_collect_statistics = COLLECT_STATISTICS;
2793     cur_test_run.stat_collect_flags = STAT_TYPE_ROUNDS |
2794                                       STAT_TYPE_BLOCKS |
2795                                       STAT_TYPE_BLOCKS_MANY_PUSH |
2796                                       STAT_TYPE_BLOCKS_NO_PUSH |
2797                                       STAT_TYPE_BLOCKS_NO_PULL |
2798                                       STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL |
2799                                       STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL |
2800                                       STAT_TYPE_ISSUED_PUSH_SEND |
2801                                       STAT_TYPE_ISSUED_PULL_REQ |
2802                                       STAT_TYPE_ISSUED_PULL_REP |
2803                                       STAT_TYPE_SENT_PUSH_SEND |
2804                                       STAT_TYPE_SENT_PULL_REQ |
2805                                       STAT_TYPE_SENT_PULL_REP |
2806                                       STAT_TYPE_RECV_PUSH_SEND |
2807                                       STAT_TYPE_RECV_PULL_REQ |
2808                                       STAT_TYPE_RECV_PULL_REP;
2809     cur_test_run.have_collect_view = COLLECT_VIEW;
2810     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300);
2811
2812     /* 'Clean' directory */
2813     (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
2814     GNUNET_DISK_directory_create ("/tmp/rps/");
2815   }
2816
2817   rps_peers = GNUNET_new_array (num_peers, struct RPSPeer);
2818   peer_map = GNUNET_CONTAINER_multipeermap_create (num_peers, GNUNET_NO);
2819   rps_peer_ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
2820   if ( (2 == mal_type) ||
2821        (3 == mal_type))
2822     target_peer = &rps_peer_ids[num_peers - 2];
2823   if (profiler_eval == cur_test_run.eval_cb)
2824     eval_peer = &rps_peers[num_peers - 1];    /* FIXME: eval_peer could be a
2825                                                  malicious peer if not careful
2826                                                  with the malicious portion */
2827
2828   ok = 1;
2829   ret_value = GNUNET_TESTBED_test_run (cur_test_run.name,
2830                                        "test_rps.conf",
2831                                        num_peers,
2832                                        0, NULL, NULL,
2833                                        &run, NULL);
2834   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2835               "_test_run returned.\n");
2836   if (GNUNET_OK != ret_value)
2837   {
2838     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2839                 "Test did not run successfully!\n");
2840   }
2841
2842   ret_value = cur_test_run.eval_cb();
2843   if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
2844   {
2845     GNUNET_array_grow (rps_peers->cur_view,
2846                        rps_peers->cur_view_count,
2847                        0);
2848   }
2849   GNUNET_free (rps_peers);
2850   GNUNET_free (rps_peer_ids);
2851   GNUNET_CONTAINER_multipeermap_destroy (peer_map);
2852   return ret_value;
2853 }
2854
2855 /* end of test_rps.c */