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 (0 == k) return 1;
1875   return fac (n)
1876     /
1877     fac(k) * fac(n - k);
1878 }
1879
1880 /**
1881  * @brief is b in view of a?
1882  *
1883  * @param a
1884  * @param b
1885  *
1886  * @return
1887  */
1888 static int is_in_view (uint32_t a, uint32_t b)
1889 {
1890   uint32_t i;
1891   for (i = 0; i < rps_peers[a].cur_view_count; i++)
1892   {
1893     if (0 == memcmp (rps_peers[b].peer_id,
1894           &rps_peers[a].cur_view[i],
1895           sizeof (struct GNUNET_PeerIdentity)))
1896     {
1897       return GNUNET_YES;
1898     }
1899   }
1900   return GNUNET_NO;
1901 }
1902
1903 static uint32_t get_idx_of_pid (const struct GNUNET_PeerIdentity *pid)
1904 {
1905   uint32_t i;
1906
1907   for (i = 0; i < num_peers; i++)
1908   {
1909     if (0 == memcmp (pid,
1910           rps_peers[i].peer_id,
1911           sizeof (struct GNUNET_PeerIdentity)))
1912     {
1913       return i;
1914     }
1915   }
1916   //return 0; /* Should not happen - make compiler happy */
1917   GNUNET_assert (0);
1918 }
1919
1920 /**
1921  * @brief Counts number of peers in view of a that have b in their view
1922  *
1923  * @param a
1924  * @param uint32_tb
1925  *
1926  * @return
1927  */
1928 static uint32_t count_containing_views (uint32_t a, uint32_t b)
1929 {
1930   uint32_t i;
1931   uint32_t peer_idx;
1932   uint32_t count = 0;
1933
1934   for (i = 0; i < rps_peers[a].cur_view_count; i++)
1935   {
1936     peer_idx = get_idx_of_pid (&rps_peers[a].cur_view[i]);
1937     if (GNUNET_YES == is_in_view (peer_idx, b))
1938     {
1939       count++;
1940     }
1941   }
1942   return count;
1943 }
1944
1945 /**
1946  * @brief Computes the probability for each other peer to be selected by the
1947  * sampling process based on the views of all peers
1948  *
1949  * @param peer_idx index of the peer that is about to sample
1950  */
1951 static void compute_probabilities (uint32_t peer_idx)
1952 {
1953   //double probs[num_peers] = { 0 };
1954   double probs[num_peers];
1955   size_t probs_as_str_size = (num_peers * 6 + 1) * sizeof (char);
1956   char *probs_as_str = GNUNET_malloc (probs_as_str_size);
1957   char *probs_as_str_cpy;
1958   uint32_t i;
1959   double prob_push;
1960   double prob_pull;
1961   uint32_t view_size;
1962   uint32_t cont_views;
1963   int tmp;
1964   uint32_t count_non_zero_prob = 0;
1965
1966   /* Firstly without knowledge of old views */
1967   for (i = 0; i < num_peers; i++)
1968   {
1969     view_size = rps_peers[i].cur_view_count;
1970     /* For peer i the probability of being sampled is
1971      * evenly distributed among all possibly observed peers. */
1972     /* We could have observed a peer in three cases:
1973      *   1. peer sent a push
1974      *   2. peer was contained in a pull reply
1975      *   3. peer was in history (sampler) - ignored for now */
1976     /* 1. Probability of having received a push from peer i */
1977     if ((GNUNET_YES == is_in_view (i, peer_idx)) &&
1978         (1 <= (0.45 * view_size)))
1979     {
1980       prob_push = 1.0 * binom (0.45 * view_size, 1)
1981         /
1982         binom (view_size, 0.45 * view_size);
1983     } else {
1984       prob_push = 0;
1985     }
1986     /* 2. Probability of peer i being contained in pulls */
1987     // FIXME this computation is not yet correct
1988     view_size = rps_peers[peer_idx].cur_view_count;
1989     cont_views = count_containing_views (i, peer_idx);
1990     prob_pull = 1.0 -
1991       (1.0 / binom (view_size, 0.45 * view_size));
1992     probs[i] = prob_push + prob_pull - (prob_push * prob_pull);
1993
1994     if (0 != probs[i]) count_non_zero_prob++;
1995   }
1996   /* normalize */
1997   if (0 != count_non_zero_prob)
1998   {
1999     for (i = 0; i < num_peers; i++)
2000     {
2001       probs[i] = probs[i] * (1.0 / count_non_zero_prob);
2002     }
2003   } else {
2004     for (i = 0; i < num_peers; i++)
2005     {
2006       probs[i] = 0;
2007     }
2008   }
2009   /* str repr */
2010   for (i = 0; i < num_peers; i++)
2011   {
2012     probs_as_str_cpy = GNUNET_strndup (probs_as_str, probs_as_str_size);
2013     tmp = GNUNET_snprintf (probs_as_str,
2014                            probs_as_str_size,
2015                            "%s %3.2f", probs_as_str_cpy, probs[i]);
2016     GNUNET_free (probs_as_str_cpy);
2017     GNUNET_assert (0 <= tmp);
2018   }
2019
2020   to_file (rps_peers[peer_idx].file_name_probs, probs_as_str);
2021   GNUNET_free (probs_as_str);
2022 }
2023
2024 /**
2025  * @brief This counts the number of peers in which views a given peer occurs.
2026  *
2027  * It also stores this value in the rps peer.
2028  *
2029  * @param peer_idx the index of the peer to count the representation
2030  *
2031  * @return the number of occurrences
2032  */
2033 static uint32_t count_peer_in_views_2 (uint32_t peer_idx)
2034 {
2035   uint32_t i, j;
2036   uint32_t count = 0;
2037
2038   for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2039   {
2040     for (j = 0; j < rps_peers[i].cur_view_count; j++) /* entry in view */
2041     {
2042       if (0 == memcmp (rps_peers[peer_idx].peer_id,
2043             &rps_peers[i].cur_view[j],
2044             sizeof (struct GNUNET_PeerIdentity)))
2045       {
2046         count++;
2047         break;
2048       }
2049     }
2050   }
2051   rps_peers[peer_idx].count_in_views = count;
2052   return count;
2053 }
2054
2055 static uint32_t cumulated_view_sizes ()
2056 {
2057   uint32_t i;
2058
2059   view_sizes = 0;
2060   for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2061   {
2062     view_sizes += rps_peers[i].cur_view_count;
2063   }
2064   return view_sizes;
2065 }
2066
2067 static void count_peer_in_views (uint32_t *count_peers)
2068 {
2069   uint32_t i, j;
2070
2071   for (i = 0; i < num_peers; i++) /* Peer in which view is counted */
2072   {
2073     for (j = 0; j < rps_peers[i].cur_view_count; j++) /* entry in view */
2074     {
2075       if (0 == memcmp (rps_peers[i].peer_id,
2076             &rps_peers[i].cur_view[j],
2077             sizeof (struct GNUNET_PeerIdentity)))
2078       {
2079         count_peers[i]++;
2080       }
2081     }
2082   }
2083 }
2084
2085 void compute_diversity ()
2086 {
2087   uint32_t i;
2088   /* ith entry represents the numer of occurrences in other peer's views */
2089   uint32_t *count_peers = GNUNET_new_array (num_peers, uint32_t);
2090   uint32_t views_total_size;
2091   double expected;
2092   /* deviation from expected number of peers */
2093   double *deviation = GNUNET_new_array (num_peers, double);
2094
2095   views_total_size = 0;
2096   expected = 0;
2097
2098   /* For each peer count its representation in other peer's views*/
2099   for (i = 0; i < num_peers; i++) /* Peer to count */
2100   {
2101     views_total_size += rps_peers[i].cur_view_count;
2102     count_peer_in_views (count_peers);
2103     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2104                "Counted representation of %" PRIu32 "th peer [%s]: %" PRIu32"\n",
2105                i,
2106                GNUNET_i2s (rps_peers[i].peer_id),
2107                count_peers[i]);
2108   }
2109
2110   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2111              "size of all views combined: %" PRIu32 "\n",
2112              views_total_size);
2113   expected = ((double) 1/num_peers) * views_total_size;
2114   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2115              "Expected number of occurrences of each peer in all views: %f\n",
2116              expected);
2117   for (i = 0; i < num_peers; i++) /* Peer to count */
2118   {
2119     deviation[i] = expected - count_peers[i];
2120     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2121                "Deviation from expectation: %f\n", deviation[i]);
2122   }
2123   GNUNET_free (count_peers);
2124   GNUNET_free (deviation);
2125 }
2126
2127 void print_view_sizes()
2128 {
2129   uint32_t i;
2130
2131   for (i = 0; i < num_peers; i++) /* Peer to count */
2132   {
2133     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2134                "View size of %" PRIu32 ". [%s] is %" PRIu32 "\n",
2135                i,
2136                GNUNET_i2s (rps_peers[i].peer_id),
2137                rps_peers[i].cur_view_count);
2138   }
2139 }
2140
2141 void all_views_updated_cb()
2142 {
2143   compute_diversity();
2144   print_view_sizes();
2145 }
2146
2147 void view_update_cb (void *cls,
2148                      uint64_t view_size,
2149                      const struct GNUNET_PeerIdentity *peers)
2150 {
2151   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2152               "View was updated (%" PRIu64 ")\n", view_size);
2153   struct RPSPeer *rps_peer = (struct RPSPeer *) cls;
2154   to_file ("/tmp/rps/view_sizes.txt",
2155          "%" PRIu64 " %" PRIu32 "",
2156          rps_peer->index,
2157          view_size);
2158   for (int i = 0; i < view_size; i++)
2159   {
2160     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2161                "\t%s\n", GNUNET_i2s (&peers[i]));
2162   }
2163   GNUNET_array_grow (rps_peer->cur_view,
2164                      rps_peer->cur_view_count,
2165                      view_size);
2166   //*rps_peer->cur_view = *peers;
2167   memcpy (rps_peer->cur_view,
2168           peers,
2169           view_size * sizeof (struct GNUNET_PeerIdentity));
2170   to_file ("/tmp/rps/count_in_views.txt",
2171          "%" PRIu64 " %" PRIu32 "",
2172          rps_peer->index,
2173          count_peer_in_views_2 (rps_peer->index));
2174   cumulated_view_sizes();
2175   to_file ("/tmp/rps/repr.txt",
2176          "%" PRIu64 /* index */
2177          " %" PRIu32 /* occurrence in views */
2178          " %" PRIu32 /* view sizes */
2179          " %f" /* fraction of repr in views */
2180          " %f" /* average view size */
2181          " %f" /* prob of occurrence in view slot */
2182          " %f" "", /* exp frac of repr in views */
2183          rps_peer->index,
2184          count_peer_in_views_2 (rps_peer->index),
2185          view_sizes,
2186          count_peer_in_views_2 (rps_peer->index) / (view_size * 1.0), /* fraction of representation in views */
2187          view_sizes / (view_size * 1.0), /* average view size */
2188          1.0 /view_size, /* prob of occurrence in view slot */
2189          (1.0/view_size) * (view_sizes/view_size) /* expected fraction of repr in views */
2190          );
2191   compute_probabilities (rps_peer->index);
2192   all_views_updated_cb();
2193 }
2194
2195 static void
2196 pre_profiler (struct RPSPeer *rps_peer, struct GNUNET_RPS_Handle *h)
2197 {
2198   rps_peer->file_name_probs = store_prefix_file_name (rps_peer, "probs");
2199   GNUNET_RPS_view_request (h, 0, view_update_cb, rps_peer);
2200 }
2201
2202 void write_final_stats (void){
2203   uint32_t i;
2204
2205   for (i = 0; i < num_peers; i++)
2206   {
2207     to_file ("/tmp/rps/final_stats.dat",
2208              "%" PRIu32 " " /* index */
2209              "%s %" /* id */
2210              PRIu64 " %" /* rounds */
2211              PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" /* blocking */
2212              PRIu64 " %" PRIu64 " %" PRIu64 " %" /* issued */
2213              PRIu64 " %" PRIu64 " %" PRIu64 " %" /* sent */
2214              PRIu64 " %" PRIu64 " %" PRIu64 /* recv */,
2215              i,
2216              GNUNET_i2s (rps_peers[i].peer_id),
2217              rps_peers[i].num_rounds,
2218              rps_peers[i].num_blocks,
2219              rps_peers[i].num_blocks_many_push,
2220              rps_peers[i].num_blocks_no_push,
2221              rps_peers[i].num_blocks_no_pull,
2222              rps_peers[i].num_blocks_many_push_no_pull,
2223              rps_peers[i].num_blocks_no_push_no_pull,
2224              rps_peers[i].num_issued_push,
2225              rps_peers[i].num_issued_pull_req,
2226              rps_peers[i].num_issued_pull_rep,
2227              rps_peers[i].num_sent_push,
2228              rps_peers[i].num_sent_pull_req,
2229              rps_peers[i].num_sent_pull_rep,
2230              rps_peers[i].num_recv_push,
2231              rps_peers[i].num_recv_pull_req,
2232              rps_peers[i].num_recv_pull_rep);
2233   }
2234 }
2235
2236 /**
2237  * Continuation called by #GNUNET_STATISTICS_get() functions.
2238  *
2239  * Remembers that this specific statistics value was received for this peer.
2240  * Checks whether all peers received their statistics yet.
2241  * Issues the shutdown.
2242  *
2243  * @param cls closure
2244  * @param success #GNUNET_OK if statistics were
2245  *        successfully obtained, #GNUNET_SYSERR if not.
2246  */
2247 void
2248 post_test_shutdown_ready_cb (void *cls,
2249                              int success)
2250 {
2251   struct STATcls *stat_cls = (struct STATcls *) cls;
2252   struct RPSPeer *rps_peer = stat_cls->rps_peer;
2253   if (GNUNET_OK == success)
2254   {
2255     /* set flag that we we got the value */
2256     rps_peer->stat_collected_flags |= stat_cls->stat_type;
2257   } else {
2258     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2259         "Peer %u did not receive statistics value\n",
2260         rps_peer->index);
2261     GNUNET_free (stat_cls);
2262     GNUNET_break (0);
2263   }
2264
2265   if (NULL != rps_peer->stat_op &&
2266       GNUNET_YES == check_statistics_collect_completed_single_peer (rps_peer))
2267   {
2268     GNUNET_TESTBED_operation_done (rps_peer->stat_op);
2269   }
2270
2271   write_final_stats ();
2272   if (GNUNET_YES == check_statistics_collect_completed())
2273   {
2274     //write_final_stats ();
2275     GNUNET_free (stat_cls);
2276     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2277         "Shutting down\n");
2278     GNUNET_SCHEDULER_shutdown ();
2279   } else {
2280     GNUNET_free (stat_cls);
2281   }
2282 }
2283
2284 /**
2285  * @brief Converts string representation to the corresponding #STAT_TYPE enum.
2286  *
2287  * @param stat_str string representation of statistics specifier
2288  *
2289  * @return corresponding enum
2290  */
2291 enum STAT_TYPE stat_str_2_type (const char *stat_str)
2292 {
2293   if (0 == strncmp ("# rounds blocked - no pull replies", stat_str, strlen ("# rounds blocked - no pull replies")))
2294   {
2295     return STAT_TYPE_BLOCKS_NO_PULL;
2296   }
2297   else if (0 == strncmp ("# rounds blocked - too many pushes, no pull replies", stat_str, strlen ("# rounds blocked - too many pushes, no pull replies")))
2298   {
2299     return STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL;
2300   }
2301   else if (0 == strncmp ("# rounds blocked - too many pushes", stat_str, strlen ("# rounds blocked - too many pushes")))
2302   {
2303     return STAT_TYPE_BLOCKS_MANY_PUSH;
2304   }
2305   else if (0 == strncmp ("# rounds blocked - no pushes, no pull replies", stat_str, strlen ("# rounds blocked - no pushes, no pull replies")))
2306   {
2307     return STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL;
2308   }
2309   else if (0 == strncmp ("# rounds blocked - no pushes", stat_str, strlen ("# rounds blocked - no pushes")))
2310   {
2311     return STAT_TYPE_BLOCKS_NO_PUSH;
2312   }
2313   else if (0 == strncmp ("# rounds blocked", stat_str, strlen ("# rounds blocked")))
2314   {
2315     return STAT_TYPE_BLOCKS;
2316   }
2317   else if (0 == strncmp ("# rounds", stat_str, strlen ("# rounds")))
2318   {
2319     return STAT_TYPE_ROUNDS;
2320   }
2321   else if (0 == strncmp ("# push send issued", stat_str, strlen ("# push send issued")))
2322   {
2323     return STAT_TYPE_ISSUED_PUSH_SEND;
2324   }
2325   else if (0 == strncmp ("# pull request send issued", stat_str, strlen ("# pull request send issued")))
2326   {
2327     return STAT_TYPE_ISSUED_PULL_REQ;
2328   }
2329   else if (0 == strncmp ("# pull reply send issued", stat_str, strlen ("# pull reply send issued")))
2330   {
2331     return STAT_TYPE_ISSUED_PULL_REP;
2332   }
2333   else if (0 == strncmp ("# pushes sent", stat_str, strlen ("# pushes sent")))
2334   {
2335     return STAT_TYPE_SENT_PUSH_SEND;
2336   }
2337   else if (0 == strncmp ("# pull requests sent", stat_str, strlen ("# pull requests sent")))
2338   {
2339     return STAT_TYPE_SENT_PULL_REQ;
2340   }
2341   else if (0 == strncmp ("# pull replys sent", stat_str, strlen ("# pull replys sent")))
2342   {
2343     return STAT_TYPE_SENT_PULL_REP;
2344   }
2345   else if (0 == strncmp ("# push message received", stat_str, strlen ("# push message received")))
2346   {
2347     return STAT_TYPE_RECV_PUSH_SEND;
2348   }
2349   else if (0 == strncmp ("# pull request message received", stat_str, strlen ("# pull request message received")))
2350   {
2351     return STAT_TYPE_RECV_PULL_REQ;
2352   }
2353   else if (0 == strncmp ("# pull reply messages received", stat_str, strlen ("# pull reply messages received")))
2354   {
2355     return STAT_TYPE_RECV_PULL_REP;
2356   }
2357   return STAT_TYPE_MAX;
2358 }
2359
2360
2361 /**
2362  * @brief Converts #STAT_TYPE enum to the equivalent string representation that
2363  * is stored with the statistics service.
2364  *
2365  * @param stat_type #STAT_TYPE enum
2366  *
2367  * @return string representation that matches statistics value
2368  */
2369 char* stat_type_2_str (enum STAT_TYPE stat_type)
2370 {
2371   switch (stat_type)
2372   {
2373     case STAT_TYPE_ROUNDS:
2374       return "# rounds";
2375     case STAT_TYPE_BLOCKS:
2376       return "# rounds blocked";
2377     case STAT_TYPE_BLOCKS_MANY_PUSH:
2378       return "# rounds blocked - too many pushes";
2379     case STAT_TYPE_BLOCKS_NO_PUSH:
2380       return "# rounds blocked - no pushes";
2381     case STAT_TYPE_BLOCKS_NO_PULL:
2382       return "# rounds blocked - no pull replies";
2383     case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL:
2384       return "# rounds blocked - too many pushes, no pull replies";
2385     case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL:
2386       return "# rounds blocked - no pushes, no pull replies";
2387     case STAT_TYPE_ISSUED_PUSH_SEND:
2388       return "# push send issued";
2389     case STAT_TYPE_ISSUED_PULL_REQ:
2390       return "# pull request send issued";
2391     case STAT_TYPE_ISSUED_PULL_REP:
2392       return "# pull reply send issued";
2393     case STAT_TYPE_SENT_PUSH_SEND:
2394       return "# pushes sent";
2395     case STAT_TYPE_SENT_PULL_REQ:
2396       return "# pull requests sent";
2397     case STAT_TYPE_SENT_PULL_REP:
2398       return "# pull replys sent";
2399     case STAT_TYPE_RECV_PUSH_SEND:
2400       return "# push message received";
2401     case STAT_TYPE_RECV_PULL_REQ:
2402       return "# pull request message received";
2403     case STAT_TYPE_RECV_PULL_REP:
2404       return "# pull reply messages received";
2405     case STAT_TYPE_MAX:
2406     default:
2407       return "ERROR";
2408       ;
2409   }
2410 }
2411
2412 /**
2413  * Callback function to process statistic values.
2414  *
2415  * @param cls closure
2416  * @param subsystem name of subsystem that created the statistic
2417  * @param name the name of the datum
2418  * @param value the current value
2419  * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
2420  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
2421  */
2422 int
2423 stat_iterator (void *cls,
2424                const char *subsystem,
2425                const char *name,
2426                uint64_t value,
2427                int is_persistent)
2428 {
2429   const struct STATcls *stat_cls = (const struct STATcls *) cls;
2430   struct RPSPeer *rps_peer = (struct RPSPeer *) stat_cls->rps_peer;
2431   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got stat value: %s - %" PRIu64 "\n",
2432       //stat_type_2_str (stat_cls->stat_type),
2433       name,
2434       value);
2435   to_file (rps_peer->file_name_stats,
2436           "%s: %" PRIu64 "\n",
2437           name,
2438           value);
2439   switch (stat_str_2_type (name))
2440   {
2441     case STAT_TYPE_ROUNDS:
2442       rps_peer->num_rounds = value;
2443       break;
2444     case STAT_TYPE_BLOCKS:
2445       rps_peer->num_blocks = value;
2446       break;
2447     case STAT_TYPE_BLOCKS_MANY_PUSH:
2448       rps_peer->num_blocks_many_push = value;
2449       break;
2450     case STAT_TYPE_BLOCKS_NO_PUSH:
2451       rps_peer->num_blocks_no_push = value;
2452       break;
2453     case STAT_TYPE_BLOCKS_NO_PULL:
2454       rps_peer->num_blocks_no_pull = value;
2455       break;
2456     case STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL:
2457       rps_peer->num_blocks_many_push_no_pull = value;
2458       break;
2459     case STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL:
2460       rps_peer->num_blocks_no_push_no_pull = value;
2461       break;
2462     case STAT_TYPE_ISSUED_PUSH_SEND:
2463       rps_peer->num_issued_push = value;
2464       break;
2465     case STAT_TYPE_ISSUED_PULL_REQ:
2466       rps_peer->num_issued_pull_req = value;
2467       break;
2468     case STAT_TYPE_ISSUED_PULL_REP:
2469       rps_peer->num_issued_pull_rep = value;
2470       break;
2471     case STAT_TYPE_SENT_PUSH_SEND:
2472       rps_peer->num_sent_push = value;
2473       break;
2474     case STAT_TYPE_SENT_PULL_REQ:
2475       rps_peer->num_sent_pull_req = value;
2476       break;
2477     case STAT_TYPE_SENT_PULL_REP:
2478       rps_peer->num_sent_pull_rep = value;
2479       break;
2480     case STAT_TYPE_RECV_PUSH_SEND:
2481       rps_peer->num_recv_push = value;
2482       break;
2483     case STAT_TYPE_RECV_PULL_REQ:
2484       rps_peer->num_recv_pull_req = value;
2485       break;
2486     case STAT_TYPE_RECV_PULL_REP:
2487       rps_peer->num_recv_pull_rep = value;
2488       break;
2489     case STAT_TYPE_MAX:
2490     default:
2491       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2492                  "Unknown statistics string: %s\n",
2493                  name);
2494       break;
2495   }
2496   return GNUNET_OK;
2497 }
2498
2499 void post_profiler (struct RPSPeer *rps_peer)
2500 {
2501   if (COLLECT_STATISTICS != cur_test_run.have_collect_statistics)
2502   {
2503     return;
2504   }
2505
2506   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2507       "Going to request statistic values with mask 0x%" PRIx32 "\n",
2508       cur_test_run.stat_collect_flags);
2509
2510   struct STATcls *stat_cls;
2511   uint32_t stat_type;
2512   for (stat_type = STAT_TYPE_ROUNDS;
2513       stat_type < STAT_TYPE_MAX;
2514       stat_type = stat_type <<1)
2515   {
2516     if (stat_type & cur_test_run.stat_collect_flags)
2517     {
2518       stat_cls = GNUNET_malloc (sizeof (struct STATcls));
2519       stat_cls->rps_peer = rps_peer;
2520       stat_cls->stat_type = stat_type;
2521       rps_peer->file_name_stats = store_prefix_file_name (rps_peer, "stats");
2522       GNUNET_STATISTICS_get (rps_peer->stats_h,
2523                              "rps",
2524                              stat_type_2_str (stat_type),
2525                              post_test_shutdown_ready_cb,
2526                              stat_iterator,
2527                              (struct STATcls *) stat_cls);
2528       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2529           "Requested statistics for %s (peer %" PRIu32 ")\n",
2530           stat_type_2_str (stat_type),
2531           rps_peer->index);
2532     }
2533   }
2534 }
2535
2536
2537 /***********************************************************************
2538  * /Definition of tests
2539 ***********************************************************************/
2540
2541
2542 /**
2543  * Actual "main" function for the testcase.
2544  *
2545  * @param cls closure
2546  * @param h the run handle
2547  * @param n_peers number of peers in 'peers'
2548  * @param peers handle to peers run in the testbed
2549  * @param links_succeeded the number of overlay link connection attempts that
2550  *          succeeded
2551  * @param links_failed the number of overlay link connection attempts that
2552  *          failed
2553  */
2554 static void
2555 run (void *cls,
2556      struct GNUNET_TESTBED_RunHandle *h,
2557      unsigned int n_peers,
2558      struct GNUNET_TESTBED_Peer **peers,
2559      unsigned int links_succeeded,
2560      unsigned int links_failed)
2561 {
2562   unsigned int i;
2563   struct OpListEntry *entry;
2564
2565   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
2566
2567   /* Check whether we timed out */
2568   if (n_peers != num_peers ||
2569       NULL == peers ||
2570       0 == links_succeeded)
2571   {
2572     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Going down due to args (eg. timeout)\n");
2573     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
2574     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n", num_peers);
2575     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
2576     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n", links_succeeded);
2577     GNUNET_SCHEDULER_shutdown ();
2578     return;
2579   }
2580
2581
2582   /* Initialize peers */
2583   testbed_peers = peers;
2584   num_peers_online = 0;
2585   for (i = 0; i < num_peers; i++)
2586   {
2587     entry = make_oplist_entry ();
2588     entry->index = i;
2589     rps_peers[i].index = i;
2590     if (NULL != cur_test_run.init_peer)
2591       cur_test_run.init_peer (&rps_peers[i]);
2592     if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
2593     {
2594       rps_peers->cur_view_count = 0;
2595       rps_peers->cur_view = NULL;
2596     }
2597     entry->op = GNUNET_TESTBED_peer_get_information (peers[i],
2598                                                      GNUNET_TESTBED_PIT_IDENTITY,
2599                                                      &info_cb,
2600                                                      entry);
2601   }
2602
2603   /* Bring peers up */
2604   GNUNET_assert (num_peers == n_peers);
2605   for (i = 0; i < n_peers; i++)
2606   {
2607     rps_peers[i].index = i;
2608     rps_peers[i].op =
2609       GNUNET_TESTBED_service_connect (&rps_peers[i],
2610                                       peers[i],
2611                                       "rps",
2612                                       &rps_connect_complete_cb,
2613                                       &rps_peers[i],
2614                                       &rps_connect_adapter,
2615                                       &rps_disconnect_adapter,
2616                                       &rps_peers[i]);
2617     /* Connect all peers to statistics service */
2618     if (COLLECT_STATISTICS == cur_test_run.have_collect_statistics)
2619     {
2620       rps_peers[i].stat_op =
2621         GNUNET_TESTBED_service_connect (NULL,
2622                                         peers[i],
2623                                         "statistics",
2624                                         stat_complete_cb,
2625                                         &rps_peers[i],
2626                                         &stat_connect_adapter,
2627                                         &stat_disconnect_adapter,
2628                                         &rps_peers[i]);
2629     }
2630   }
2631
2632   if (NULL != churn_task)
2633     GNUNET_SCHEDULER_cancel (churn_task);
2634   shutdown_task = GNUNET_SCHEDULER_add_delayed (timeout, &shutdown_op, NULL);
2635 }
2636
2637
2638 /**
2639  * Entry point for the testcase, sets up the testbed.
2640  *
2641  * @param argc unused
2642  * @param argv unused
2643  * @return 0 on success
2644  */
2645 int
2646 main (int argc, char *argv[])
2647 {
2648   int ret_value;
2649
2650   /* Defaults for tests */
2651   num_peers = 5;
2652   cur_test_run.name = "test-rps-default";
2653   cur_test_run.init_peer = default_init_peer;
2654   cur_test_run.pre_test = NULL;
2655   cur_test_run.reply_handle = default_reply_handle;
2656   cur_test_run.eval_cb = default_eval_cb;
2657   cur_test_run.post_test = NULL;
2658   cur_test_run.have_churn = HAVE_CHURN;
2659   cur_test_run.have_collect_statistics = NO_COLLECT_STATISTICS;
2660   cur_test_run.stat_collect_flags = 0;
2661   cur_test_run.have_collect_view = NO_COLLECT_VIEW;
2662   churn_task = NULL;
2663   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
2664
2665   if (strstr (argv[0], "malicious") != NULL)
2666   {
2667     cur_test_run.pre_test = mal_pre;
2668     cur_test_run.main_test = mal_cb;
2669     cur_test_run.init_peer = mal_init_peer;
2670
2671     if (strstr (argv[0], "_1") != NULL)
2672     {
2673       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 1\n");
2674       cur_test_run.name = "test-rps-malicious_1";
2675       mal_type = 1;
2676     }
2677     else if (strstr (argv[0], "_2") != NULL)
2678     {
2679       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 2\n");
2680       cur_test_run.name = "test-rps-malicious_2";
2681       mal_type = 2;
2682     }
2683     else if (strstr (argv[0], "_3") != NULL)
2684     {
2685       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 3\n");
2686       cur_test_run.name = "test-rps-malicious_3";
2687       mal_type = 3;
2688     }
2689   }
2690
2691   else if (strstr (argv[0], "_single_req") != NULL)
2692   {
2693     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test single request\n");
2694     cur_test_run.name = "test-rps-single-req";
2695     cur_test_run.main_test = single_req_cb;
2696     cur_test_run.have_churn = HAVE_NO_CHURN;
2697   }
2698
2699   else if (strstr (argv[0], "_delayed_reqs") != NULL)
2700   {
2701     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test delayed requests\n");
2702     cur_test_run.name = "test-rps-delayed-reqs";
2703     cur_test_run.main_test = delay_req_cb;
2704     cur_test_run.have_churn = HAVE_NO_CHURN;
2705   }
2706
2707   else if (strstr (argv[0], "_seed_big") != NULL)
2708   {
2709     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding (num_peers > GNUNET_MAX_MESSAGE_SIZE)\n");
2710     num_peers = 1;
2711     cur_test_run.name = "test-rps-seed-big";
2712     cur_test_run.main_test = seed_big_cb;
2713     cur_test_run.eval_cb = no_eval;
2714     cur_test_run.have_churn = HAVE_NO_CHURN;
2715     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
2716   }
2717
2718   else if (strstr (argv[0], "_single_peer_seed") != NULL)
2719   {
2720     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on a single peer\n");
2721     cur_test_run.name = "test-rps-single-peer-seed";
2722     cur_test_run.main_test = single_peer_seed_cb;
2723     cur_test_run.have_churn = HAVE_NO_CHURN;
2724   }
2725
2726   else if (strstr (argv[0], "_seed_request") != NULL)
2727   {
2728     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on multiple peers\n");
2729     cur_test_run.name = "test-rps-seed-request";
2730     cur_test_run.main_test = seed_req_cb;
2731     cur_test_run.have_churn = HAVE_NO_CHURN;
2732   }
2733
2734   else if (strstr (argv[0], "_seed") != NULL)
2735   {
2736     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding\n");
2737     cur_test_run.name = "test-rps-seed";
2738     cur_test_run.main_test = seed_cb;
2739     cur_test_run.eval_cb = no_eval;
2740     cur_test_run.have_churn = HAVE_NO_CHURN;
2741   }
2742
2743   else if (strstr (argv[0], "_req_cancel") != NULL)
2744   {
2745     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test cancelling a request\n");
2746     cur_test_run.name = "test-rps-req-cancel";
2747     num_peers = 1;
2748     cur_test_run.main_test = req_cancel_cb;
2749     cur_test_run.eval_cb = no_eval;
2750     cur_test_run.have_churn = HAVE_NO_CHURN;
2751     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
2752   }
2753
2754   else if (strstr (argv[0], "_churn") != NULL)
2755   {
2756     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test churn\n");
2757     cur_test_run.name = "test-rps-churn";
2758     num_peers = 5;
2759     cur_test_run.init_peer = default_init_peer;
2760     cur_test_run.main_test = churn_test_cb;
2761     cur_test_run.reply_handle = default_reply_handle;
2762     cur_test_run.eval_cb = default_eval_cb;
2763     cur_test_run.have_churn = HAVE_CHURN;
2764     cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
2765     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
2766   }
2767
2768   else if (strstr (argv[0], "profiler") != NULL)
2769   {
2770     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "This is the profiler\n");
2771     cur_test_run.name = "test-rps-profiler";
2772     num_peers = 10;
2773     mal_type = 3;
2774     cur_test_run.init_peer = profiler_init_peer;
2775     //cur_test_run.pre_test = mal_pre;
2776     cur_test_run.pre_test = pre_profiler;
2777     cur_test_run.main_test = profiler_cb;
2778     cur_test_run.reply_handle = profiler_reply_handle;
2779     cur_test_run.eval_cb = profiler_eval;
2780     cur_test_run.post_test = post_profiler;
2781     cur_test_run.request_interval = 2;
2782     cur_test_run.num_requests = 5;
2783     cur_test_run.have_churn = HAVE_CHURN;
2784     cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
2785     cur_test_run.have_collect_statistics = COLLECT_STATISTICS;
2786     cur_test_run.stat_collect_flags = STAT_TYPE_ROUNDS |
2787                                       STAT_TYPE_BLOCKS |
2788                                       STAT_TYPE_BLOCKS_MANY_PUSH |
2789                                       STAT_TYPE_BLOCKS_NO_PUSH |
2790                                       STAT_TYPE_BLOCKS_NO_PULL |
2791                                       STAT_TYPE_BLOCKS_MANY_PUSH_NO_PULL |
2792                                       STAT_TYPE_BLOCKS_NO_PUSH_NO_PULL |
2793                                       STAT_TYPE_ISSUED_PUSH_SEND |
2794                                       STAT_TYPE_ISSUED_PULL_REQ |
2795                                       STAT_TYPE_ISSUED_PULL_REP |
2796                                       STAT_TYPE_SENT_PUSH_SEND |
2797                                       STAT_TYPE_SENT_PULL_REQ |
2798                                       STAT_TYPE_SENT_PULL_REP |
2799                                       STAT_TYPE_RECV_PUSH_SEND |
2800                                       STAT_TYPE_RECV_PULL_REQ |
2801                                       STAT_TYPE_RECV_PULL_REP;
2802     cur_test_run.have_collect_view = COLLECT_VIEW;
2803     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300);
2804
2805     /* 'Clean' directory */
2806     (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
2807     GNUNET_DISK_directory_create ("/tmp/rps/");
2808   }
2809
2810   rps_peers = GNUNET_new_array (num_peers, struct RPSPeer);
2811   peer_map = GNUNET_CONTAINER_multipeermap_create (num_peers, GNUNET_NO);
2812   rps_peer_ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
2813   if ( (2 == mal_type) ||
2814        (3 == mal_type))
2815     target_peer = &rps_peer_ids[num_peers - 2];
2816   if (profiler_eval == cur_test_run.eval_cb)
2817     eval_peer = &rps_peers[num_peers - 1];    /* FIXME: eval_peer could be a
2818                                                  malicious peer if not careful
2819                                                  with the malicious portion */
2820
2821   ok = 1;
2822   ret_value = GNUNET_TESTBED_test_run (cur_test_run.name,
2823                                        "test_rps.conf",
2824                                        num_peers,
2825                                        0, NULL, NULL,
2826                                        &run, NULL);
2827   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2828               "_test_run returned.\n");
2829   if (GNUNET_OK != ret_value)
2830   {
2831     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2832                 "Test did not run successfully!\n");
2833   }
2834
2835   ret_value = cur_test_run.eval_cb();
2836   if (NO_COLLECT_VIEW == cur_test_run.have_collect_view)
2837   {
2838     GNUNET_array_grow (rps_peers->cur_view,
2839                        rps_peers->cur_view_count,
2840                        0);
2841   }
2842   GNUNET_free (rps_peers);
2843   GNUNET_free (rps_peer_ids);
2844   GNUNET_CONTAINER_multipeermap_destroy (peer_map);
2845   return ret_value;
2846 }
2847
2848 /* end of test_rps.c */