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 /**
  67  * Operation map entry
  68  */
  69 struct OpListEntry
  70 {
  71   /**
  72    * DLL next ptr
  73    */
  74   struct OpListEntry *next;
  75
  76   /**
  77    * DLL prev ptr
  78    */
  79   struct OpListEntry *prev;
  80
  81   /**
  82    * The testbed operation
  83    */
  84   struct GNUNET_TESTBED_Operation *op;
  85
  86   /**
  87    * Depending on whether we start or stop NSE service at the peer set this to 1
  88    * or -1
  89    */
  90   int delta;
  91
  92   /**
  93    * Index of the regarding peer
  94    */
  95   unsigned int index;
  96 };
  97
  98 /**
  99  * OpList DLL head
 100  */
 101 static struct OpListEntry *oplist_head;
 102
 103 /**
 104  * OpList DLL tail
 105  */
 106 static struct OpListEntry *oplist_tail;
 107
 108
 109 /**
 110  * A pending reply: A request was sent and the reply is pending.
 111  */
 112 struct PendingReply
 113 {
 114   /**
 115    * DLL next,prev ptr
 116    */
 117   struct PendingReply *next;
 118   struct PendingReply *prev;
 119
 120   /**
 121    * Handle to the request we are waiting for
 122    */
 123   struct GNUNET_RPS_Request_Handle *req_handle;
 124
 125   /**
 126    * The peer that requested
 127    */
 128   struct RPSPeer *rps_peer;
 129 };
 130
 131
 132 /**
 133  * A pending request: A request was not made yet but is scheduled for later.
 134  */
 135 struct PendingRequest
 136 {
 137   /**
 138    * DLL next,prev ptr
 139    */
 140   struct PendingRequest *next;
 141   struct PendingRequest *prev;
 142
 143   /**
 144    * Handle to the request we are waiting for
 145    */
 146   struct GNUNET_SCHEDULER_Task *request_task;
 147
 148   /**
 149    * The peer that requested
 150    */
 151   struct RPSPeer *rps_peer;
 152 };
 153
 154
 155 /**
 156  * Information we track for each peer.
 157  */
 158 struct RPSPeer
 159 {
 160   /**
 161    * Index of the peer.
 162    */
 163   unsigned int index;
 164
 165   /**
 166    * Handle for RPS connect operation.
 167    */
 168   struct GNUNET_TESTBED_Operation *op;
 169
 170   /**
 171    * Handle to RPS service.
 172    */
 173   struct GNUNET_RPS_Handle *rps_handle;
 174
 175   /**
 176    * ID of the peer.
 177    */
 178   struct GNUNET_PeerIdentity *peer_id;
 179
 180   /**
 181    * A request handle to check for an request
 182    */
 183   //struct GNUNET_RPS_Request_Handle *req_handle;
 184
 185   /**
 186    * Peer on- or offline?
 187    */
 188   int online;
 189
 190   /**
 191    * Number of Peer IDs to request
 192    */
 193   unsigned int num_ids_to_request;
 194
 195   /**
 196    * Pending requests DLL
 197    */
 198   struct PendingRequest *pending_req_head;
 199   struct PendingRequest *pending_req_tail;
 200
 201   /**
 202    * Number of pending requests
 203    */
 204   unsigned int num_pending_reqs;
 205
 206   /**
 207    * Pending replies DLL
 208    */
 209   struct PendingReply *pending_rep_head;
 210   struct PendingReply *pending_rep_tail;
 211
 212   /**
 213    * Number of pending replies
 214    */
 215   unsigned int num_pending_reps;
 216
 217   /**
 218    * Number of received PeerIDs
 219    */
 220   unsigned int num_recv_ids;
 221 };
 222
 223
 224 /**
 225  * Information for all the peers.
 226  */
 227 static struct RPSPeer *rps_peers;
 228
 229 /**
 230  * Peermap to get the index of a given peer ID quick.
 231  */
 232 static struct GNUNET_CONTAINER_MultiPeerMap *peer_map;
 233
 234 /**
 235  * IDs of the peers.
 236  */
 237 static struct GNUNET_PeerIdentity *rps_peer_ids;
 238
 239 /**
 240  * ID of the targeted peer.
 241  */
 242 static struct GNUNET_PeerIdentity *target_peer;
 243
 244 /**
 245  * ID of the peer that requests for the evaluation.
 246  */
 247 static struct RPSPeer *eval_peer;
 248
 249 /**
 250  * Number of online peers.
 251  */
 252 static unsigned int num_peers_online;
 253
 254 /**
 255  * Return value from 'main'.
 256  */
 257 static int ok;
 258
 259 /**
 260  * Identifier for the churn task that runs periodically
 261  */
 262 static struct GNUNET_SCHEDULER_Task *churn_task;
 263
 264 /**
 265  * Called to initialise the given RPSPeer
 266  */
 267 typedef void (*InitPeer) (struct RPSPeer *rps_peer);
 268
 269 /**
 270  * Called directly after connecting to the service
 271  */
 272 typedef void (*PreTest) (void *cls, struct GNUNET_RPS_Handle *h);
 273
 274 /**
 275  * Called from within #rps_connect_complete_cb ()
 276  * Executes functions to test the api/service
 277  */
 278 typedef void (*MainTest) (struct RPSPeer *rps_peer);
 279
 280 /**
 281  * Callback called once the requested random peers are available
 282  */
 283 typedef void (*ReplyHandle) (void *cls,
 284                              uint64_t n,
 285                              const struct GNUNET_PeerIdentity *recv_peers);
 286
 287 /**
 288  * Called directly before disconnecting from the service
 289  */
 290 typedef void (*PostTest) (void *cls, struct GNUNET_RPS_Handle *h);
 291
 292 /**
 293  * Function called after disconnect to evaluate test success
 294  */
 295 typedef int (*EvaluationCallback) (void);
 296
 297
 298 /**
 299  * Structure to define a single test
 300  */
 301 struct SingleTestRun
 302 {
 303   /**
 304    * Name of the test
 305    */
 306   char *name;
 307
 308   /**
 309    * Called to initialise peer
 310    */
 311   InitPeer init_peer;
 312
 313   /**
 314    * Called directly after connecting to the service
 315    */
 316   PreTest pre_test;
 317
 318   /**
 319    * Function to execute the functions to be tested
 320    */
 321   MainTest main_test;
 322
 323   /**
 324    * Callback called once the requested peers are available
 325    */
 326   ReplyHandle reply_handle;
 327
 328   /**
 329    * Called directly before disconnecting from the service
 330    */
 331   PostTest post_test;
 332
 333   /**
 334    * Function to evaluate the test results
 335    */
 336   EvaluationCallback eval_cb;
 337
 338   /**
 339    * Request interval
 340    */
 341   uint32_t request_interval;
 342
 343   /**
 344    * Number of Requests to make.
 345    */
 346   uint32_t num_requests;
 347
 348   /**
 349    * Run with churn
 350    */
 351   int have_churn;
 352 } cur_test_run;
 353
 354 /**
 355  * Are we shutting down?
 356  */
 357 static int in_shutdown;
 358
 359 /**
 360  * Append arguments to file
 361  */
 362 static void
 363 tofile_ (const char *file_name, const char *line)
 364 {
 365   struct GNUNET_DISK_FileHandle *f;
 366   /* char output_buffer[512]; */
 367   size_t size;
 368   /* int size; */
 369   size_t size2;
 370
 371   if (NULL == (f = GNUNET_DISK_file_open (file_name,
 372                                           GNUNET_DISK_OPEN_APPEND |
 373                                           GNUNET_DISK_OPEN_WRITE |
 374                                           GNUNET_DISK_OPEN_CREATE,
 375                                           GNUNET_DISK_PERM_USER_READ |
 376                                           GNUNET_DISK_PERM_USER_WRITE |
 377                                           GNUNET_DISK_PERM_GROUP_READ |
 378                                           GNUNET_DISK_PERM_OTHER_READ)))
 379   {
 380     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 381                 "Not able to open file %s\n",
 382                 file_name);
 383     return;
 384   }
 385   /* size = GNUNET_snprintf (output_buffer,
 386                           sizeof (output_buffer),
 387                           "%llu %s\n",
 388                           GNUNET_TIME_absolute_get ().abs_value_us,
 389                           line);
 390   if (0 > size)
 391   {
 392     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 393                 "Failed to write string to buffer (size: %i)\n",
 394                 size);
 395     return;
 396   } */
 397
 398   size = strlen (line) * sizeof (char);
 399
 400   size2 = GNUNET_DISK_file_write (f, line, size);
 401   if (size != size2)
 402   {
 403     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 404                 "Unable to write to file! (Size: %lu, size2: %lu)\n",
 405                 size,
 406                 size2);
 407     if (GNUNET_YES != GNUNET_DISK_file_close (f))
 408     {
 409       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 410                   "Unable to close file\n");
 411     }
 412     return;
 413   }
 414
 415   if (GNUNET_YES != GNUNET_DISK_file_close (f))
 416   {
 417     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 418                 "Unable to close file\n");
 419   }
 420 }
 421
 422 /**
 423  * This function is used to facilitate writing important information to disk
 424  */
 425 #define tofile(file_name, ...) do {\
 426   char tmp_buf[512];\
 427     int size;\
 428     size = GNUNET_snprintf(tmp_buf,sizeof(tmp_buf),__VA_ARGS__);\
 429     if (0 > size)\
 430       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,\
 431                      "Failed to create tmp_buf\n");\
 432     else\
 433       tofile_(file_name,tmp_buf);\
 434   } while (0);
 435
 436
 437 /**
 438  * Write the ids and their according index in the given array to a file
 439  * Unused
 440  */
 441 /* static void
 442 ids_to_file (char *file_name,
 443              struct GNUNET_PeerIdentity *peer_ids,
 444              unsigned int num_peer_ids)
 445 {
 446   unsigned int i;
 447
 448   for (i=0 ; i < num_peer_ids ; i++)
 449   {
 450     to_file (file_name,
 451              "%u\t%s",
 452              i,
 453              GNUNET_i2s_full (&peer_ids[i]));
 454   }
 455 } */
 456
 457 /**
 458  * Test the success of a single test
 459  */
 460 static int
 461 evaluate (void)
 462 {
 463   unsigned int i;
 464   int tmp_ok;
 465
 466   tmp_ok = 1;
 467
 468   for (i = 0; i < num_peers; i++)
 469   {
 470     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 471         "%u. peer [%s] received %u of %u expected peer_ids: %i\n",
 472         i,
 473         GNUNET_i2s (rps_peers[i].peer_id),
 474         rps_peers[i].num_recv_ids,
 475         rps_peers[i].num_ids_to_request,
 476         (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids));
 477     tmp_ok &= (rps_peers[i].num_ids_to_request == rps_peers[i].num_recv_ids);
 478   }
 479   return tmp_ok? 0 : 1;
 480 }
 481
 482
 483 /**
 484  * Creates an oplist entry and adds it to the oplist DLL
 485  */
 486 static struct OpListEntry *
 487 make_oplist_entry ()
 488 {
 489   struct OpListEntry *entry;
 490
 491   entry = GNUNET_new (struct OpListEntry);
 492   GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
 493   return entry;
 494 }
 495
 496
 497 /**
 498  * Task run on timeout to shut everything down.
 499  */
 500 static void
 501 shutdown_op (void *cls)
 502 {
 503   unsigned int i;
 504
 505   in_shutdown = GNUNET_YES;
 506   if (NULL != churn_task)
 507   {
 508     GNUNET_SCHEDULER_cancel (churn_task);
 509     churn_task = NULL;
 510   }
 511   for (i = 0; i < num_peers; i++)
 512     if (NULL != rps_peers[i].op)
 513       GNUNET_TESTBED_operation_done (rps_peers[i].op);
 514   GNUNET_SCHEDULER_shutdown ();
 515 }
 516
 517
 518 /**
 519  * Seed peers.
 520  */
 521 static void
 522 seed_peers (void *cls)
 523 {
 524   struct RPSPeer *peer = cls;
 525   unsigned int amount;
 526   unsigned int i;
 527
 528   // TODO if malicious don't seed mal peers
 529   amount = round (.5 * num_peers);
 530
 531   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding peers:\n");
 532   for (i = 0 ; i < amount ; i++)
 533     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding %u. peer: %s\n",
 534                 i,
 535                 GNUNET_i2s (&rps_peer_ids[i]));
 536
 537   GNUNET_RPS_seed_ids (peer->rps_handle, amount, rps_peer_ids);
 538 }
 539
 540
 541 /**
 542  * Seed peers.
 543  */
 544 static void
 545 seed_peers_big (void *cls)
 546 {
 547   struct RPSPeer *peer = cls;
 548   unsigned int seed_msg_size;
 549   uint32_t num_peers_max;
 550   unsigned int amount;
 551   unsigned int i;
 552
 553   seed_msg_size = 8; /* sizeof (struct GNUNET_RPS_CS_SeedMessage) */
 554   num_peers_max = (GNUNET_MAX_MESSAGE_SIZE - seed_msg_size) /
 555     sizeof (struct GNUNET_PeerIdentity);
 556   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 557       "Peers that fit in one seed msg; %u\n",
 558       num_peers_max);
 559   amount = num_peers_max + (0.5 * num_peers_max);
 560   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 561       "Seeding many (%u) peers:\n",
 562       amount);
 563   struct GNUNET_PeerIdentity ids_to_seed[amount];
 564   for (i = 0; i < amount; i++)
 565   {
 566     ids_to_seed[i] = *peer->peer_id;
 567     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Seeding %u. peer: %s\n",
 568                 i,
 569                 GNUNET_i2s (&ids_to_seed[i]));
 570   }
 571
 572   GNUNET_RPS_seed_ids (peer->rps_handle, amount, ids_to_seed);
 573 }
 574
 575 /**
 576  * Get the id of peer i.
 577  */
 578   void
 579 info_cb (void *cb_cls,
 580          struct GNUNET_TESTBED_Operation *op,
 581          const struct GNUNET_TESTBED_PeerInformation *pinfo,
 582          const char *emsg)
 583 {
 584   struct OpListEntry *entry = (struct OpListEntry *) cb_cls;
 585
 586   if (NULL == pinfo || NULL != emsg)
 587   {
 588     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got Error: %s\n", emsg);
 589     GNUNET_TESTBED_operation_done (entry->op);
 590     return;
 591   }
 592
 593   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 594               "Peer %u is %s\n",
 595               entry->index,
 596               GNUNET_i2s (pinfo->result.id));
 597
 598   rps_peer_ids[entry->index] = *(pinfo->result.id);
 599   rps_peers[entry->index].peer_id = &rps_peer_ids[entry->index];
 600
 601   GNUNET_assert (GNUNET_OK ==
 602       GNUNET_CONTAINER_multipeermap_put (peer_map,
 603         &rps_peer_ids[entry->index],
 604         &rps_peers[entry->index],
 605         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 606   tofile ("/tmp/rps/peer_ids",
 607            "%u\t%s\n",
 608            entry->index,
 609            GNUNET_i2s_full (&rps_peer_ids[entry->index]));
 610
 611   GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
 612   GNUNET_TESTBED_operation_done (entry->op);
 613   GNUNET_free (entry);
 614 }
 615
 616
 617 /**
 618  * Callback to be called when RPS service connect operation is completed
 619  *
 620  * @param cls the callback closure from functions generating an operation
 621  * @param op the operation that has been finished
 622  * @param ca_result the RPS service handle returned from rps_connect_adapter
 623  * @param emsg error message in case the operation has failed; will be NULL if
 624  *          operation has executed successfully.
 625  */
 626 static void
 627 rps_connect_complete_cb (void *cls,
 628                          struct GNUNET_TESTBED_Operation *op,
 629                          void *ca_result,
 630                          const char *emsg)
 631 {
 632   struct RPSPeer *rps_peer = cls;
 633   struct GNUNET_RPS_Handle *rps = ca_result;
 634
 635   rps_peer->rps_handle = rps;
 636   rps_peer->online = GNUNET_YES;
 637   num_peers_online++;
 638
 639   GNUNET_assert (op == rps_peer->op);
 640   if (NULL != emsg)
 641   {
 642     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 643                 "Failed to connect to RPS service: %s\n",
 644                 emsg);
 645     ok = 1;
 646     GNUNET_SCHEDULER_shutdown ();
 647     return;
 648   }
 649
 650   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started client successfully\n");
 651
 652   cur_test_run.main_test (rps_peer);
 653 }
 654
 655
 656 /**
 657  * Adapter function called to establish a connection to
 658  * the RPS service.
 659  *
 660  * @param cls closure
 661  * @param cfg configuration of the peer to connect to; will be available until
 662  *          GNUNET_TESTBED_operation_done() is called on the operation returned
 663  *          from GNUNET_TESTBED_service_connect()
 664  * @return service handle to return in 'op_result', NULL on error
 665  */
 666 static void *
 667 rps_connect_adapter (void *cls,
 668                                  const struct GNUNET_CONFIGURATION_Handle *cfg)
 669 {
 670   struct GNUNET_RPS_Handle *h;
 671
 672   h = GNUNET_RPS_connect (cfg);
 673
 674   if (NULL != cur_test_run.pre_test)
 675     cur_test_run.pre_test (cls, h);
 676
 677   return h;
 678 }
 679
 680
 681 /**
 682  * Adapter function called to destroy connection to
 683  * RPS service.
 684  *
 685  * @param cls closure
 686  * @param op_result service handle returned from the connect adapter
 687  */
 688 static void
 689 rps_disconnect_adapter (void *cls,
 690                                           void *op_result)
 691 {
 692   struct RPSPeer *peer = cls;
 693   struct GNUNET_RPS_Handle *h = op_result;
 694   GNUNET_assert (NULL != peer);
 695   GNUNET_RPS_disconnect (h);
 696   peer->rps_handle = NULL;
 697 }
 698
 699
 700 /***********************************************************************
 701  * Definition of tests
 702 ***********************************************************************/
 703
 704 // TODO check whether tests can be stopped earlier
 705 static int
 706 default_eval_cb (void)
 707 {
 708   return evaluate ();
 709 }
 710
 711 static int
 712 no_eval (void)
 713 {
 714   return 0;
 715 }
 716
 717 /**
 718  * Initialise given RPSPeer
 719  */
 720 static void default_init_peer (struct RPSPeer *rps_peer)
 721 {
 722   rps_peer->num_ids_to_request = 1;
 723 }
 724
 725 /**
 726  * Callback to call on receipt of a reply
 727  *
 728  * @param cls closure
 729  * @param n number of peers
 730  * @param recv_peers the received peers
 731  */
 732 static void
 733 default_reply_handle (void *cls,
 734                       uint64_t n,
 735                       const struct GNUNET_PeerIdentity *recv_peers)
 736 {
 737   struct RPSPeer *rps_peer;
 738   struct PendingReply *pending_rep = (struct PendingReply *) cls;
 739   unsigned int i;
 740
 741   rps_peer = pending_rep->rps_peer;
 742   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
 743                                rps_peer->pending_rep_tail,
 744                                pending_rep);
 745   rps_peer->num_pending_reps--;
 746   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 747               "[%s] got %" PRIu64 " peers:\n",
 748               GNUNET_i2s (rps_peer->peer_id),
 749               n);
 750
 751   for (i = 0; i < n; i++)
 752   {
 753     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 754                 "%u: %s\n",
 755                 i,
 756                 GNUNET_i2s (&recv_peers[i]));
 757
 758     rps_peer->num_recv_ids++;
 759   }
 760
 761   if (0 == evaluate ())
 762   {
 763     GNUNET_SCHEDULER_shutdown ();
 764   }
 765 }
 766
 767 /**
 768  * Request random peers.
 769  */
 770 static void
 771 request_peers (void *cls)
 772 {
 773   struct PendingRequest *pending_req = cls;
 774   struct RPSPeer *rps_peer;
 775   struct PendingReply *pending_rep;
 776
 777   if (GNUNET_YES == in_shutdown)
 778     return;
 779   rps_peer = pending_req->rps_peer;
 780   GNUNET_assert (1 <= rps_peer->num_pending_reqs);
 781   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
 782                                rps_peer->pending_req_tail,
 783                                pending_req);
 784   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 785               "Requesting one peer\n");
 786   pending_rep = GNUNET_new (struct PendingReply);
 787   pending_rep->rps_peer = rps_peer;
 788   pending_rep->req_handle = GNUNET_RPS_request_peers (rps_peer->rps_handle,
 789       1,
 790       cur_test_run.reply_handle,
 791       pending_rep);
 792   GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_rep_head,
 793                                     rps_peer->pending_rep_tail,
 794                                     pending_rep);
 795   rps_peer->num_pending_reps++;
 796   rps_peer->num_pending_reqs--;
 797 }
 798
 799 static void
 800 cancel_pending_req (struct PendingRequest *pending_req)
 801 {
 802   struct RPSPeer *rps_peer;
 803
 804   rps_peer = pending_req->rps_peer;
 805   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_req_head,
 806                                rps_peer->pending_req_tail,
 807                                pending_req);
 808   rps_peer->num_pending_reqs--;
 809   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 810               "Cancelling pending request\n");
 811   GNUNET_SCHEDULER_cancel (pending_req->request_task);
 812   GNUNET_free (pending_req);
 813 }
 814
 815 static void
 816 cancel_request (struct PendingReply *pending_rep)
 817 {
 818   struct RPSPeer *rps_peer;
 819
 820   rps_peer = pending_rep->rps_peer;
 821   GNUNET_CONTAINER_DLL_remove (rps_peer->pending_rep_head,
 822                                rps_peer->pending_rep_tail,
 823                                pending_rep);
 824   rps_peer->num_pending_reps--;
 825   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 826               "Cancelling request\n");
 827   GNUNET_RPS_request_cancel (pending_rep->req_handle);
 828   GNUNET_free (pending_rep);
 829 }
 830
 831 /**
 832  * Cancel a request.
 833  */
 834 static void
 835 cancel_request_cb (void *cls)
 836 {
 837   struct RPSPeer *rps_peer = cls;
 838   struct PendingReply *pending_rep;
 839
 840   if (GNUNET_YES == in_shutdown)
 841     return;
 842   pending_rep = rps_peer->pending_rep_head;
 843   GNUNET_assert (1 <= rps_peer->num_pending_reps);
 844   cancel_request (pending_rep);
 845 }
 846
 847
 848 /**
 849  * Schedule requests for peer @a rps_peer that have neither been scheduled, nor
 850  * issued, nor replied
 851  */
 852 void
 853 schedule_missing_requests (struct RPSPeer *rps_peer)
 854 {
 855   unsigned int i;
 856   struct PendingRequest *pending_req;
 857
 858   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 859       "Scheduling %u - %u missing requests\n",
 860       rps_peer->num_ids_to_request,
 861       rps_peer->num_pending_reqs + rps_peer->num_pending_reps);
 862   GNUNET_assert (rps_peer->num_pending_reqs + rps_peer->num_pending_reps <=
 863       rps_peer->num_ids_to_request);
 864   for (i = rps_peer->num_pending_reqs + rps_peer->num_pending_reps;
 865        i < rps_peer->num_ids_to_request; i++)
 866   {
 867     pending_req = GNUNET_new (struct PendingRequest);
 868     pending_req->rps_peer = rps_peer;
 869     pending_req->request_task = GNUNET_SCHEDULER_add_delayed (
 870         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
 871           cur_test_run.request_interval * i),
 872         request_peers,
 873         pending_req);
 874     GNUNET_CONTAINER_DLL_insert_tail (rps_peer->pending_req_head,
 875                                       rps_peer->pending_req_tail,
 876                                       pending_req);
 877     rps_peer->num_pending_reqs++;
 878   }
 879 }
 880
 881 void
 882 cancel_pending_req_rep (struct RPSPeer *rps_peer)
 883 {
 884   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 885       "Cancelling all (pending) requests.\n");
 886   while (NULL != rps_peer->pending_req_head)
 887     cancel_pending_req (rps_peer->pending_req_head);
 888   GNUNET_assert (0 == rps_peer->num_pending_reqs);
 889   while (NULL != rps_peer->pending_rep_head)
 890     cancel_request (rps_peer->pending_rep_head);
 891   GNUNET_assert (0 == rps_peer->num_pending_reps);
 892 }
 893
 894 /***********************************
 895  * MALICIOUS
 896 ***********************************/
 897
 898 /**
 899  * Initialise only non-mal RPSPeers
 900  */
 901 static void mal_init_peer (struct RPSPeer *rps_peer)
 902 {
 903   if (rps_peer->index >= round (portion * num_peers))
 904     rps_peer->num_ids_to_request = 1;
 905 }
 906
 907 static void
 908 mal_pre (void *cls, struct GNUNET_RPS_Handle *h)
 909 {
 910   #ifdef ENABLE_MALICIOUS
 911   uint32_t num_mal_peers;
 912   struct RPSPeer *rps_peer = (struct RPSPeer *) cls;
 913
 914   GNUNET_assert ( (1 >= portion) &&
 915                   (0 <  portion) );
 916   num_mal_peers = round (portion * num_peers);
 917
 918   if (rps_peer->index < num_mal_peers)
 919   {
 920     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 921                 "%u. peer [%s] of %" PRIu32 " malicious peers turning malicious\n",
 922                 rps_peer->index,
 923                 GNUNET_i2s (rps_peer->peer_id),
 924                 num_mal_peers);
 925
 926     GNUNET_RPS_act_malicious (h, mal_type, num_mal_peers,
 927                               rps_peer_ids, target_peer);
 928   }
 929   #endif /* ENABLE_MALICIOUS */
 930 }
 931
 932 static void
 933 mal_cb (struct RPSPeer *rps_peer)
 934 {
 935   uint32_t num_mal_peers;
 936
 937   #ifdef ENABLE_MALICIOUS
 938   GNUNET_assert ( (1 >= portion) &&
 939                   (0 <  portion) );
 940   num_mal_peers = round (portion * num_peers);
 941
 942   if (rps_peer->index >= num_mal_peers)
 943   { /* It's useless to ask a malicious peer about a random sample -
 944        it's not sampling */
 945     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
 946                                   seed_peers, rps_peer);
 947     schedule_missing_requests (rps_peer);
 948   }
 949   #endif /* ENABLE_MALICIOUS */
 950 }
 951
 952
 953 /***********************************
 954  * SINGLE_REQUEST
 955 ***********************************/
 956 static void
 957 single_req_cb (struct RPSPeer *rps_peer)
 958 {
 959   schedule_missing_requests (rps_peer);
 960 }
 961
 962 /***********************************
 963  * DELAYED_REQUESTS
 964 ***********************************/
 965 static void
 966 delay_req_cb (struct RPSPeer *rps_peer)
 967 {
 968   schedule_missing_requests (rps_peer);
 969 }
 970
 971 /***********************************
 972  * SEED
 973 ***********************************/
 974 static void
 975 seed_cb (struct RPSPeer *rps_peer)
 976 {
 977   GNUNET_SCHEDULER_add_delayed (
 978       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
 979       seed_peers, rps_peer);
 980 }
 981
 982 /***********************************
 983  * SEED_BIG
 984 ***********************************/
 985 static void
 986 seed_big_cb (struct RPSPeer *rps_peer)
 987 {
 988   // TODO test seeding > GNUNET_MAX_MESSAGE_SIZE peers
 989   GNUNET_SCHEDULER_add_delayed (
 990       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
 991       seed_peers_big, rps_peer);
 992 }
 993
 994 /***********************************
 995  * SINGLE_PEER_SEED
 996 ***********************************/
 997 static void
 998 single_peer_seed_cb (struct RPSPeer *rps_peer)
 999 {
1000   // TODO
1001 }
1002
1003 /***********************************
1004  * SEED_REQUEST
1005 ***********************************/
1006 static void
1007 seed_req_cb (struct RPSPeer *rps_peer)
1008 {
1009   GNUNET_SCHEDULER_add_delayed (
1010       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
1011       seed_peers, rps_peer);
1012   schedule_missing_requests (rps_peer);
1013 }
1014
1015 //TODO start big mal
1016
1017 /***********************************
1018  * REQUEST_CANCEL
1019 ***********************************/
1020 static void
1021 req_cancel_cb (struct RPSPeer *rps_peer)
1022 {
1023   schedule_missing_requests (rps_peer);
1024   GNUNET_SCHEDULER_add_delayed (
1025       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
1026                                      (cur_test_run.request_interval + 1)),
1027       cancel_request_cb, rps_peer);
1028 }
1029
1030 /***********************************
1031  * CHURN
1032 ***********************************/
1033
1034 static void
1035 churn (void *cls);
1036
1037 static void
1038 churn_test_cb (struct RPSPeer *rps_peer)
1039 {
1040   /* Start churn */
1041   if (GNUNET_YES == cur_test_run.have_churn && NULL == churn_task)
1042   {
1043     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1044                 "Starting churn task\n");
1045     churn_task = GNUNET_SCHEDULER_add_delayed (
1046           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
1047           churn,
1048           NULL);
1049   } else {
1050     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1051                 "Not starting churn task\n");
1052   }
1053
1054   schedule_missing_requests (rps_peer);
1055 }
1056
1057 /***********************************
1058  * PROFILER
1059 ***********************************/
1060
1061 /**
1062  * Callback to be called when RPS service is started or stopped at peers
1063  *
1064  * @param cls NULL
1065  * @param op the operation handle
1066  * @param emsg NULL on success; otherwise an error description
1067  */
1068 static void
1069 churn_cb (void *cls,
1070           struct GNUNET_TESTBED_Operation *op,
1071           const char *emsg)
1072 {
1073   // FIXME
1074   struct OpListEntry *entry = cls;
1075
1076   GNUNET_TESTBED_operation_done (entry->op);
1077   if (NULL != emsg)
1078   {
1079     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop RPS at a peer\n");
1080     GNUNET_SCHEDULER_shutdown ();
1081     return;
1082   }
1083   GNUNET_assert (0 != entry->delta);
1084
1085   num_peers_online += entry->delta;
1086
1087   if (0 > entry->delta)
1088   { /* Peer hopefully just went offline */
1089     if (GNUNET_YES != rps_peers[entry->index].online)
1090     {
1091       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1092                   "peer %s was expected to go offline but is still marked as online\n",
1093                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1094       GNUNET_break (0);
1095     }
1096     else
1097     {
1098       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1099                   "peer %s probably went offline as expected\n",
1100                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1101     }
1102     rps_peers[entry->index].online = GNUNET_NO;
1103   }
1104
1105   else if (0 < entry->delta)
1106   { /* Peer hopefully just went online */
1107     if (GNUNET_NO != rps_peers[entry->index].online)
1108     {
1109       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1110                   "peer %s was expected to go online but is still marked as offline\n",
1111                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1112       GNUNET_break (0);
1113     }
1114     else
1115     {
1116       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1117                   "peer %s probably went online as expected\n",
1118                   GNUNET_i2s (rps_peers[entry->index].peer_id));
1119       if (NULL != cur_test_run.pre_test)
1120       {
1121         cur_test_run.pre_test (&rps_peers[entry->index],
1122             rps_peers[entry->index].rps_handle);
1123         schedule_missing_requests (&rps_peers[entry->index]);
1124       }
1125     }
1126     rps_peers[entry->index].online = GNUNET_YES;
1127   }
1128
1129   GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
1130   GNUNET_free (entry);
1131   //if (num_peers_in_round[current_round] == peers_running)
1132   //  run_round ();
1133 }
1134
1135 static void
1136 manage_service_wrapper (unsigned int i, unsigned int j, int delta,
1137     double prob_go_on_off)
1138 {
1139   struct OpListEntry *entry;
1140   uint32_t prob;
1141
1142   prob = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
1143                                    UINT32_MAX);
1144   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1145               "%u. selected peer (%u: %s) is %s.\n",
1146               i,
1147               j,
1148               GNUNET_i2s (rps_peers[j].peer_id),
1149               (0 > delta) ? "online" : "offline");
1150   if (prob < prob_go_on_off * UINT32_MAX)
1151   {
1152     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1153                 "%s goes %s\n",
1154                 GNUNET_i2s (rps_peers[j].peer_id),
1155                 (0 > delta) ? "offline" : "online");
1156
1157     if (0 > delta)
1158       cancel_pending_req_rep (&rps_peers[j]);
1159     entry = make_oplist_entry ();
1160     entry->delta = delta;
1161     entry->index = j;
1162     entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
1163                                                     testbed_peers[j],
1164                                                     "rps",
1165                                                     &churn_cb,
1166                                                     entry,
1167                                                     (0 > delta) ? 0 : 1);
1168   }
1169 }
1170
1171
1172 static void
1173 churn (void *cls)
1174 {
1175   unsigned int i;
1176   unsigned int j;
1177   double portion_online;
1178   unsigned int *permut;
1179   double prob_go_offline;
1180   double portion_go_online;
1181   double portion_go_offline;
1182
1183   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1184               "Churn function executing\n");
1185
1186   /* Compute the probability for an online peer to go offline
1187    * this round */
1188   portion_online = num_peers_online * 1.0 / num_peers;
1189   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1190               "Portion online: %f\n",
1191               portion_online);
1192   portion_go_online = ((1 - portion_online) * .5 * .66);
1193   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1194               "Portion that should go online: %f\n",
1195               portion_go_online);
1196   portion_go_offline = (portion_online + portion_go_online) - .75;
1197   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1198               "Portion that probably goes offline: %f\n",
1199               portion_go_offline);
1200   prob_go_offline = portion_go_offline / (portion_online * .5);
1201   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1202               "Probability of a selected online peer to go offline: %f\n",
1203               prob_go_offline);
1204
1205   permut = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
1206                                          (unsigned int) num_peers);
1207
1208   /* Go over 50% randomly chosen peers */
1209   for (i = 0; i < .5 * num_peers; i++)
1210   {
1211     j = permut[i];
1212
1213     /* If online, shut down with certain probability */
1214     if (GNUNET_YES == rps_peers[j].online)
1215     {
1216       manage_service_wrapper (i, j, -1, prob_go_offline);
1217     }
1218
1219     /* If offline, restart with certain probability */
1220     else if (GNUNET_NO == rps_peers[j].online)
1221     {
1222       manage_service_wrapper (i, j, 1, 0.66);
1223     }
1224   }
1225
1226   GNUNET_free (permut);
1227
1228   churn_task = GNUNET_SCHEDULER_add_delayed (
1229         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2),
1230         churn,
1231         NULL);
1232 }
1233
1234
1235 /**
1236  * Initialise given RPSPeer
1237  */
1238 static void profiler_init_peer (struct RPSPeer *rps_peer)
1239 {
1240   if (num_peers - 1 == rps_peer->index)
1241     rps_peer->num_ids_to_request = cur_test_run.num_requests;
1242 }
1243
1244
1245 /**
1246  * Callback to call on receipt of a reply
1247  *
1248  * @param cls closure
1249  * @param n number of peers
1250  * @param recv_peers the received peers
1251  */
1252 static void
1253 profiler_reply_handle (void *cls,
1254                       uint64_t n,
1255                       const struct GNUNET_PeerIdentity *recv_peers)
1256 {
1257   struct RPSPeer *rps_peer;
1258   struct RPSPeer *rcv_rps_peer;
1259   char *file_name;
1260   char *file_name_dh;
1261   unsigned int i;
1262   struct PendingReply *pending_rep = (struct PendingReply *) cls;
1263
1264   rps_peer = pending_rep->rps_peer;
1265   file_name = "/tmp/rps/received_ids";
1266   file_name_dh = "/tmp/rps/diehard_input";
1267   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1268               "[%s] got %" PRIu64 " peers:\n",
1269               GNUNET_i2s (rps_peer->peer_id),
1270               n);
1271   for (i = 0; i < n; i++)
1272   {
1273     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1274                 "%u: %s\n",
1275                 i,
1276                 GNUNET_i2s (&recv_peers[i]));
1277     tofile (file_name,
1278              "%s\n",
1279              GNUNET_i2s_full (&recv_peers[i]));
1280     rcv_rps_peer = GNUNET_CONTAINER_multipeermap_get (peer_map, &recv_peers[i]);
1281     GNUNET_assert (NULL != rcv_rps_peer);
1282     tofile (file_name_dh,
1283              "%" PRIu32 "\n",
1284              (uint32_t) rcv_rps_peer->index);
1285   }
1286   default_reply_handle (cls, n, recv_peers);
1287 }
1288
1289
1290 static void
1291 profiler_cb (struct RPSPeer *rps_peer)
1292 {
1293   /* Start churn */
1294   if (GNUNET_YES == cur_test_run.have_churn && NULL == churn_task)
1295   {
1296     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1297                 "Starting churn task\n");
1298     churn_task = GNUNET_SCHEDULER_add_delayed (
1299           GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
1300           churn,
1301           NULL);
1302   } else {
1303     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1304                 "Not starting churn task\n");
1305   }
1306
1307   /* Only request peer ids at one peer.
1308    * (It's the before-last because last one is target of the focussed attack.)
1309    */
1310   if (eval_peer == rps_peer)
1311     schedule_missing_requests (rps_peer);
1312 }
1313
1314 /**
1315  * Function called from #profiler_eval with a filename.
1316  *
1317  * @param cls closure
1318  * @param filename complete filename (absolute path)
1319  * @return #GNUNET_OK to continue to iterate,
1320  *  #GNUNET_NO to stop iteration with no error,
1321  *  #GNUNET_SYSERR to abort iteration with error!
1322  */
1323 int
1324 file_name_cb (void *cls, const char *filename)
1325 {
1326   if (NULL != strstr (filename, "sampler_el"))
1327   {
1328     struct RPS_SamplerElement *s_elem;
1329     struct GNUNET_CRYPTO_AuthKey auth_key;
1330     const char *key_char;
1331     uint32_t i;
1332
1333     key_char = filename + 20; /* Length of "/tmp/rps/sampler_el-" */
1334     tofile (filename, "--------------------------\n");
1335
1336     auth_key = string_to_auth_key (key_char);
1337     s_elem = RPS_sampler_elem_create ();
1338     RPS_sampler_elem_set (s_elem, auth_key);
1339
1340     for (i = 0; i < num_peers; i++)
1341     {
1342       RPS_sampler_elem_next (s_elem, &rps_peer_ids[i]);
1343     }
1344     RPS_sampler_elem_destroy (s_elem);
1345   }
1346   return GNUNET_OK;
1347 }
1348
1349 /**
1350  * This is run after the test finished.
1351  *
1352  * Compute all perfect samples.
1353  */
1354 int
1355 profiler_eval (void)
1356 {
1357   /* Compute perfect sample for each sampler element */
1358   if (-1 == GNUNET_DISK_directory_scan ("/tmp/rps/", file_name_cb, NULL))
1359   {
1360     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Scan of directory failed\n");
1361   }
1362
1363   return evaluate ();
1364 }
1365
1366
1367 /***********************************************************************
1368  * /Definition of tests
1369 ***********************************************************************/
1370
1371
1372 /**
1373  * Actual "main" function for the testcase.
1374  *
1375  * @param cls closure
1376  * @param h the run handle
1377  * @param n_peers number of peers in 'peers'
1378  * @param peers handle to peers run in the testbed
1379  * @param links_succeeded the number of overlay link connection attempts that
1380  *          succeeded
1381  * @param links_failed the number of overlay link connection attempts that
1382  *          failed
1383  */
1384 static void
1385 run (void *cls,
1386      struct GNUNET_TESTBED_RunHandle *h,
1387      unsigned int n_peers,
1388      struct GNUNET_TESTBED_Peer **peers,
1389      unsigned int links_succeeded,
1390      unsigned int links_failed)
1391 {
1392   unsigned int i;
1393   struct OpListEntry *entry;
1394   uint32_t num_mal_peers;
1395
1396   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "RUN was called\n");
1397
1398   /* Check whether we timed out */
1399   if (n_peers != num_peers ||
1400       NULL == peers ||
1401       0 == links_succeeded)
1402   {
1403     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Going down due to args (eg. timeout)\n");
1404     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tn_peers: %u\n", n_peers);
1405     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tnum_peers: %" PRIu32 "\n", num_peers);
1406     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tpeers: %p\n", peers);
1407     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\tlinks_succeeded: %u\n", links_succeeded);
1408     GNUNET_SCHEDULER_shutdown ();
1409     return;
1410   }
1411
1412
1413   /* Initialize peers */
1414   testbed_peers = peers;
1415   num_peers_online = 0;
1416   for (i = 0; i < num_peers; i++)
1417   {
1418     entry = make_oplist_entry ();
1419     entry->index = i;
1420     rps_peers[i].index = i;
1421     if (NULL != cur_test_run.init_peer)
1422       cur_test_run.init_peer (&rps_peers[i]);
1423     entry->op = GNUNET_TESTBED_peer_get_information (peers[i],
1424                                                      GNUNET_TESTBED_PIT_IDENTITY,
1425                                                      &info_cb,
1426                                                      entry);
1427   }
1428
1429   num_mal_peers = round (portion * num_peers);
1430   GNUNET_assert (num_peers == n_peers);
1431   for (i = 0; i < n_peers; i++)
1432   {
1433     rps_peers[i].index = i;
1434     if ( (rps_peers[i].num_recv_ids < rps_peers[i].num_ids_to_request) ||
1435          (i < num_mal_peers) )
1436     {
1437       rps_peers[i].op =
1438         GNUNET_TESTBED_service_connect (&rps_peers[i],
1439                                         peers[i],
1440                                         "rps",
1441                                         &rps_connect_complete_cb,
1442                                         &rps_peers[i],
1443                                         &rps_connect_adapter,
1444                                         &rps_disconnect_adapter,
1445                                         &rps_peers[i]);
1446     }
1447   }
1448
1449   if (NULL != churn_task)
1450     GNUNET_SCHEDULER_cancel (churn_task);
1451   GNUNET_SCHEDULER_add_delayed (timeout, &shutdown_op, NULL);
1452 }
1453
1454
1455 /**
1456  * Entry point for the testcase, sets up the testbed.
1457  *
1458  * @param argc unused
1459  * @param argv unused
1460  * @return 0 on success
1461  */
1462 int
1463 main (int argc, char *argv[])
1464 {
1465   int ret_value;
1466
1467   num_peers = 5;
1468   cur_test_run.name = "test-rps-default";
1469   cur_test_run.init_peer = default_init_peer;
1470   cur_test_run.pre_test = NULL;
1471   cur_test_run.reply_handle = default_reply_handle;
1472   cur_test_run.eval_cb = default_eval_cb;
1473   cur_test_run.have_churn = GNUNET_YES;
1474   churn_task = NULL;
1475   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
1476
1477   if (strstr (argv[0], "malicious") != NULL)
1478   {
1479     cur_test_run.pre_test = mal_pre;
1480     cur_test_run.main_test = mal_cb;
1481     cur_test_run.init_peer = mal_init_peer;
1482
1483     if (strstr (argv[0], "_1") != NULL)
1484     {
1485       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 1\n");
1486       cur_test_run.name = "test-rps-malicious_1";
1487       mal_type = 1;
1488     }
1489     else if (strstr (argv[0], "_2") != NULL)
1490     {
1491       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 2\n");
1492       cur_test_run.name = "test-rps-malicious_2";
1493       mal_type = 2;
1494     }
1495     else if (strstr (argv[0], "_3") != NULL)
1496     {
1497       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test malicious peer type 3\n");
1498       cur_test_run.name = "test-rps-malicious_3";
1499       mal_type = 3;
1500     }
1501   }
1502
1503   else if (strstr (argv[0], "_single_req") != NULL)
1504   {
1505     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test single request\n");
1506     cur_test_run.name = "test-rps-single-req";
1507     cur_test_run.main_test = single_req_cb;
1508     cur_test_run.have_churn = GNUNET_NO;
1509   }
1510
1511   else if (strstr (argv[0], "_delayed_reqs") != NULL)
1512   {
1513     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test delayed requests\n");
1514     cur_test_run.name = "test-rps-delayed-reqs";
1515     cur_test_run.main_test = delay_req_cb;
1516     cur_test_run.have_churn = GNUNET_NO;
1517   }
1518
1519   else if (strstr (argv[0], "_seed_big") != NULL)
1520   {
1521     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding (num_peers > GNUNET_MAX_MESSAGE_SIZE)\n");
1522     num_peers = 1;
1523     cur_test_run.name = "test-rps-seed-big";
1524     cur_test_run.main_test = seed_big_cb;
1525     cur_test_run.eval_cb = no_eval;
1526     cur_test_run.have_churn = GNUNET_NO;
1527     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
1528   }
1529
1530   else if (strstr (argv[0], "_single_peer_seed") != NULL)
1531   {
1532     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on a single peer\n");
1533     cur_test_run.name = "test-rps-single-peer-seed";
1534     cur_test_run.main_test = single_peer_seed_cb;
1535     cur_test_run.have_churn = GNUNET_NO;
1536   }
1537
1538   else if (strstr (argv[0], "_seed_request") != NULL)
1539   {
1540     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on multiple peers\n");
1541     cur_test_run.name = "test-rps-seed-request";
1542     cur_test_run.main_test = seed_req_cb;
1543     cur_test_run.have_churn = GNUNET_NO;
1544   }
1545
1546   else if (strstr (argv[0], "_seed") != NULL)
1547   {
1548     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding\n");
1549     cur_test_run.name = "test-rps-seed";
1550     cur_test_run.main_test = seed_cb;
1551     cur_test_run.eval_cb = no_eval;
1552     cur_test_run.have_churn = GNUNET_NO;
1553   }
1554
1555   else if (strstr (argv[0], "_req_cancel") != NULL)
1556   {
1557     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test cancelling a request\n");
1558     cur_test_run.name = "test-rps-req-cancel";
1559     num_peers = 1;
1560     cur_test_run.main_test = req_cancel_cb;
1561     cur_test_run.eval_cb = no_eval;
1562     cur_test_run.have_churn = GNUNET_NO;
1563     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
1564   }
1565
1566   else if (strstr (argv[0], "_churn") != NULL)
1567   {
1568     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test churn\n");
1569     cur_test_run.name = "test-rps-churn";
1570     num_peers = 5;
1571     cur_test_run.init_peer = default_init_peer;
1572     cur_test_run.main_test = churn_test_cb;
1573     cur_test_run.reply_handle = default_reply_handle;
1574     cur_test_run.eval_cb = default_eval_cb;
1575     cur_test_run.have_churn = GNUNET_YES;
1576     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
1577   }
1578
1579   else if (strstr (argv[0], "profiler") != NULL)
1580   {
1581     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "This is the profiler\n");
1582     cur_test_run.name = "test-rps-profiler";
1583     num_peers = 10;
1584     mal_type = 3;
1585     cur_test_run.init_peer = profiler_init_peer;
1586     cur_test_run.pre_test = mal_pre;
1587     cur_test_run.main_test = profiler_cb;
1588     cur_test_run.reply_handle = profiler_reply_handle;
1589     cur_test_run.eval_cb = profiler_eval;
1590     cur_test_run.request_interval = 2;
1591     cur_test_run.num_requests = 5;
1592     cur_test_run.have_churn = GNUNET_YES;
1593     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90);
1594
1595     /* 'Clean' directory */
1596     (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
1597     GNUNET_DISK_directory_create ("/tmp/rps/");
1598   }
1599
1600   rps_peers = GNUNET_new_array (num_peers, struct RPSPeer);
1601   peer_map = GNUNET_CONTAINER_multipeermap_create (num_peers, GNUNET_NO);
1602   rps_peer_ids = GNUNET_new_array (num_peers, struct GNUNET_PeerIdentity);
1603   if ( (2 == mal_type) ||
1604        (3 == mal_type))
1605     target_peer = &rps_peer_ids[num_peers - 2];
1606   if (profiler_eval == cur_test_run.eval_cb)
1607     eval_peer = &rps_peers[num_peers - 1];    /* FIXME: eval_peer could be a
1608                                                  malicious peer if not careful
1609                                                  with the malicious portion */
1610
1611   ok = 1;
1612   (void) GNUNET_TESTBED_test_run (cur_test_run.name,
1613                                   "test_rps.conf",
1614                                   num_peers,
1615                                   0, NULL, NULL,
1616                                   &run, NULL);
1617
1618   ret_value = cur_test_run.eval_cb();
1619   GNUNET_free (rps_peers );
1620   GNUNET_free (rps_peer_ids);
1621   GNUNET_CONTAINER_multipeermap_destroy (peer_map);
1622   return ret_value;
1623 }
1624
1625 /* end of test_rps.c */