src/cadet/test_cadet_new.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011, 2017 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 cadet/test_cadet_mq.c
  22  * @author Bart Polot
  23  * @author Christian Grothoff
  24  * @brief Test for the cadet service using mq API.
  25  */
  26 #include <stdio.h>
  27 #include "platform.h"
  28 #include "cadet_test_lib_new.h"
  29 #include "gnunet_cadet_service.h"
  30 #include "gnunet_statistics_service.h"
  31 #include <gauger.h>
  32
  33
  34 /**
  35  * Ugly workaround to unify data handlers on incoming and outgoing channels.
  36  */
  37 struct CadetTestChannelWrapper
  38 {
  39   /**
  40    * Channel pointer.
  41    */
  42   struct GNUNET_CADET_Channel *ch;
  43 };
  44
  45 /**
  46  * How many messages to send
  47  */
  48 #define TOTAL_PACKETS 500       /* Cannot exceed 64k! */
  49
  50 /**
  51  * How long until we give up on connecting the peers?
  52  */
  53 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
  54
  55 /**
  56  * Time to wait for stuff that should be rather fast
  57  */
  58 #define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
  59
  60 /**
  61  * DIFFERENT TESTS TO RUN
  62  */
  63 #define SETUP 0
  64 #define FORWARD 1
  65 #define KEEPALIVE 2
  66 #define SPEED 3
  67 #define SPEED_ACK 4
  68 #define SPEED_REL 8
  69 #define P2P_SIGNAL 10
  70
  71 /**
  72  * Which test are we running?
  73  */
  74 static int test;
  75
  76 /**
  77  * String with test name
  78  */
  79 static char *test_name;
  80
  81 /**
  82  * Flag to send traffic leaf->root in speed tests to test BCK_ACK logic.
  83  */
  84 static int test_backwards = GNUNET_NO;
  85
  86 /**
  87  * How many events have happened
  88  */
  89 static int ok;
  90
  91 /**
  92  * Number of events expected to conclude the test successfully.
  93  */
  94 static int ok_goal;
  95
  96 /**
  97  * Size of each test packet's payload
  98  */
  99 static size_t size_payload = sizeof (uint32_t);
 100
 101 /**
 102  * Operation to get peer ids.
 103  */
 104 static struct GNUNET_TESTBED_Operation *t_op[2];
 105
 106 /**
 107  * Peer ids.
 108  */
 109 static struct GNUNET_PeerIdentity *p_id[2];
 110
 111 /**
 112  * Port ID
 113  */
 114 static struct GNUNET_HashCode port;
 115
 116 /**
 117  * Peer ids counter.
 118  */
 119 static unsigned int p_ids;
 120
 121 /**
 122  * Is the setup initialized?
 123  */
 124 static int initialized;
 125
 126 /**
 127  * Number of payload packes sent.
 128  */
 129 static int data_sent;
 130
 131 /**
 132  * Number of payload packets received.
 133  */
 134 static int data_received;
 135
 136 /**
 137  * Number of payload packed acknowledgements sent.
 138  */
 139 static int ack_sent;
 140
 141 /**
 142  * Number of payload packed explicitly (app level) acknowledged.
 143  */
 144 static int ack_received;
 145
 146 /**
 147  * Total number of peers asked to run.
 148  */
 149 static unsigned long long peers_requested;
 150
 151 /**
 152  * Number of currently running peers (should be same as @c peers_requested).
 153  */
 154 static unsigned long long peers_running;
 155
 156 /**
 157  * Test context (to shut down).
 158  */
 159 struct GNUNET_CADET_TEST_Context *test_ctx;
 160
 161 /**
 162  * Task called to disconnect peers.
 163  */
 164 static struct GNUNET_SCHEDULER_Task *disconnect_task;
 165
 166 /**
 167  * Task To perform tests
 168  */
 169 static struct GNUNET_SCHEDULER_Task *test_task;
 170
 171 /**
 172  * Task runnining #send_next_msg().
 173  */
 174 static struct GNUNET_SCHEDULER_Task *send_next_msg_task;
 175
 176 /**
 177  * Cadet handle for the root peer
 178  */
 179 static struct GNUNET_CADET_Handle *h1;
 180
 181 /**
 182  * Cadet handle for the first leaf peer
 183  */
 184 static struct GNUNET_CADET_Handle *h2;
 185
 186 /**
 187  * Channel handle for the root peer
 188  */
 189 static struct GNUNET_CADET_Channel *outgoing_ch;
 190
 191 /**
 192  * Channel handle for the dest peer
 193  */
 194 static struct GNUNET_CADET_Channel *incoming_ch;
 195
 196 /**
 197  * Time we started the data transmission (after channel has been established
 198  * and initilized).
 199  */
 200 static struct GNUNET_TIME_Absolute start_time;
 201
 202 /**
 203  * Peers handle.
 204  */
 205 static struct GNUNET_TESTBED_Peer **testbed_peers;
 206
 207 /**
 208  * Statistics operation handle.
 209  */
 210 static struct GNUNET_TESTBED_Operation *stats_op;
 211
 212 /**
 213  * Keepalives sent.
 214  */
 215 static unsigned int ka_sent;
 216
 217 /**
 218  * Keepalives received.
 219  */
 220 static unsigned int ka_received;
 221
 222 /**
 223  * How many messages were dropped by CADET because of full buffers?
 224  */
 225 static unsigned int msg_dropped;
 226
 227
 228 /******************************************************************************/
 229
 230
 231 /******************************************************************************/
 232
 233
 234 /**
 235  * Get the channel considered as the "target" or "receiver", depending on
 236  * the test type and size.
 237  *
 238  * @return Channel handle of the target client, either 0 (for backward tests)
 239  *         or the last peer in the line (for other tests).
 240  */
 241 static struct GNUNET_CADET_Channel *
 242 get_target_channel ()
 243 {
 244   if (SPEED == test && GNUNET_YES == test_backwards)
 245     return outgoing_ch;
 246   else
 247     return incoming_ch;
 248 }
 249
 250
 251 /**
 252  * Show the results of the test (banwidth acheived) and log them to GAUGER
 253  */
 254 static void
 255 show_end_data (void)
 256 {
 257   static struct GNUNET_TIME_Absolute end_time;
 258   static struct GNUNET_TIME_Relative total_time;
 259
 260   end_time = GNUNET_TIME_absolute_get ();
 261   total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time);
 262   FPRINTF (stderr, "\nResults of test \"%s\"\n", test_name);
 263   FPRINTF (stderr, "Test time %s\n",
 264            GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES));
 265   FPRINTF (stderr, "Test bandwidth: %f kb/s\n", 4 * TOTAL_PACKETS * 1.0 / (total_time.rel_value_us / 1000));    // 4bytes * ms
 266   FPRINTF (stderr, "Test throughput: %f packets/s\n\n", TOTAL_PACKETS * 1000.0 / (total_time.rel_value_us / 1000));     // packets * ms
 267   GAUGER ("CADET", test_name,
 268           TOTAL_PACKETS * 1000.0 / (total_time.rel_value_us / 1000),
 269           "packets/s");
 270 }
 271
 272
 273 /**
 274  * Disconnect from cadet services af all peers, call shutdown.
 275  *
 276  * @param cls Closure (line number from which termination was requested).
 277  * @param tc Task Context.
 278  */
 279 static void
 280 disconnect_cadet_peers (void *cls)
 281 {
 282   long line = (long) cls;
 283   unsigned int i;
 284
 285   disconnect_task = NULL;
 286   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 287               "disconnecting cadet service of peers, called from line %ld\n",
 288               line);
 289   for (i = 0; i < 2; i++)
 290   {
 291     GNUNET_TESTBED_operation_done (t_op[i]);
 292   }
 293   if (NULL != outgoing_ch)
 294   {
 295     GNUNET_CADET_channel_destroy (outgoing_ch);
 296     outgoing_ch = NULL;
 297   }
 298   if (NULL != incoming_ch)
 299   {
 300     GNUNET_CADET_channel_destroy (incoming_ch);
 301     incoming_ch = NULL;
 302   }
 303   GNUNET_CADET_TEST_cleanup (test_ctx);
 304   GNUNET_SCHEDULER_shutdown ();
 305 }
 306
 307
 308 /**
 309  * Shut down peergroup, clean up.
 310  *
 311  * @param cls Closure (unused).
 312  * @param tc Task Context.
 313  */
 314 static void
 315 shutdown_task (void *cls)
 316 {
 317   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");
 318   if (NULL != send_next_msg_task)
 319   {
 320     GNUNET_SCHEDULER_cancel (send_next_msg_task);
 321     send_next_msg_task = NULL;
 322   }
 323   if (NULL != test_task)
 324   {
 325     GNUNET_SCHEDULER_cancel (test_task);
 326     test_task = NULL;
 327   }
 328   if (NULL != disconnect_task)
 329   {
 330     GNUNET_SCHEDULER_cancel (disconnect_task);
 331     disconnect_task =
 332         GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, (void *) __LINE__);
 333   }
 334 }
 335
 336
 337 /**
 338  * Stats callback. Finish the stats testbed operation and when all stats have
 339  * been iterated, shutdown the test.
 340  *
 341  * @param cls Closure (line number from which termination was requested).
 342  * @param op the operation that has been finished
 343  * @param emsg error message in case the operation has failed; will be NULL if
 344  *          operation has executed successfully.
 345  */
 346 static void
 347 stats_cont (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
 348 {
 349   GNUNET_log (GNUNET_ERROR_TYPE_INFO, " KA sent: %u, KA received: %u\n",
 350               ka_sent, ka_received);
 351   if ((KEEPALIVE == test) && ((ka_sent < 2) || (ka_sent > ka_received + 1)))
 352   {
 353     GNUNET_break (0);
 354     ok--;
 355   }
 356   GNUNET_TESTBED_operation_done (stats_op);
 357
 358   if (NULL != disconnect_task)
 359     GNUNET_SCHEDULER_cancel (disconnect_task);
 360   disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, cls);
 361 }
 362
 363
 364 /**
 365  * Process statistic values.
 366  *
 367  * @param cls closure (line number, unused)
 368  * @param peer the peer the statistic belong to
 369  * @param subsystem name of subsystem that created the statistic
 370  * @param name the name of the datum
 371  * @param value the current value
 372  * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
 373  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
 374  */
 375 static int
 376 stats_iterator (void *cls, const struct GNUNET_TESTBED_Peer *peer,
 377                 const char *subsystem, const char *name, uint64_t value,
 378                 int is_persistent)
 379 {
 380   static const char *s_sent = "# keepalives sent";
 381   static const char *s_recv = "# keepalives received";
 382   static const char *rdrops = "# messages dropped due to full buffer";
 383   static const char *cdrops = "# messages dropped due to slow client";
 384   uint32_t i;
 385
 386   i = GNUNET_TESTBED_get_index (peer);
 387   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
 388               subsystem, name, (unsigned long long) value);
 389   if (0 == strncmp (s_sent, name, strlen (s_sent)) && 0 == i)
 390     ka_sent = value;
 391   if (0 == strncmp (s_recv, name, strlen (s_recv)) && peers_requested - 1 == i)
 392     ka_received = value;
 393   if (0 == strncmp (rdrops, name, strlen (rdrops)))
 394     msg_dropped += value;
 395   if (0 == strncmp (cdrops, name, strlen (cdrops)))
 396     msg_dropped += value;
 397
 398   return GNUNET_OK;
 399 }
 400
 401
 402 /**
 403  * Task to gather all statistics.
 404  *
 405  * @param cls Closure (line from which the task was scheduled).
 406  */
 407 static void
 408 gather_stats_and_exit (void *cls)
 409 {
 410   long l = (long) cls;
 411
 412   disconnect_task = NULL;
 413   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 414               "gathering statistics from line %ld\n",
 415               l);
 416   if (NULL != outgoing_ch)
 417   {
 418     GNUNET_CADET_channel_destroy (outgoing_ch);
 419     outgoing_ch = NULL;
 420   }
 421   stats_op = GNUNET_TESTBED_get_statistics (peers_running,
 422                                             testbed_peers,
 423                                             "cadet",
 424                                             NULL,
 425                                             &stats_iterator,
 426                                             stats_cont,
 427                                             cls);
 428 }
 429
 430
 431
 432 /**
 433  * Abort test: schedule disconnect and shutdown immediately
 434  *
 435  * @param line Line in the code the abort is requested from (__LINE__).
 436  */
 437 static void
 438 abort_test (long line)
 439 {
 440   if (NULL != disconnect_task)
 441   {
 442     GNUNET_SCHEDULER_cancel (disconnect_task);
 443     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting test from %ld\n", line);
 444     disconnect_task =
 445         GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers, (void *) line);
 446   }
 447 }
 448
 449
 450 /**
 451  * Send a message on the channel with the appropriate size and payload.
 452  *
 453  * Update the appropriate *_sent counter.
 454  *
 455  * @param channel Channel to send the message on.
 456  */
 457 static void
 458 send_test_message (struct GNUNET_CADET_Channel *channel)
 459 {
 460   struct GNUNET_MQ_Envelope *env;
 461   struct GNUNET_MessageHeader *msg;
 462   uint32_t *data;
 463   int payload;
 464   int size;
 465
 466   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 467               "Sending test message on channel %p\n",
 468               channel);
 469   size = size_payload;
 470   if (GNUNET_NO == initialized)
 471   {
 472     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
 473     size += 1000;
 474     payload = data_sent;
 475     if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
 476         data_sent++;
 477   }
 478   else if (SPEED == test || SPEED_ACK == test)
 479   {
 480     if (get_target_channel() == channel)
 481     {
 482       payload = ack_sent;
 483       size += ack_sent;
 484       ack_sent++;
 485       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 486                   "Sending ACK %u [%d bytes]\n",
 487                   payload, size);
 488     }
 489     else
 490     {
 491       payload = data_sent;
 492       size += data_sent;
 493       data_sent++;
 494       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 495                   "Sending DATA %u [%d bytes]\n",
 496                   data_sent, size);
 497     }
 498   }
 499   else if (FORWARD == test)
 500   {
 501     payload = ack_sent;
 502   }
 503   else if (P2P_SIGNAL == test)
 504   {
 505     payload = data_sent;
 506   }
 507   else
 508   {
 509     GNUNET_assert (0);
 510   }
 511   env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
 512
 513   data = (uint32_t *) &msg[1];
 514   *data = htonl (payload);
 515   GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env);
 516 }
 517
 518 /**
 519  * Task to request a new data transmission in a SPEED test, without waiting
 520  * for previous messages to be sent/arrrive.
 521  *
 522  * @param cls Closure (unused).
 523  */
 524 static void
 525 send_next_msg (void *cls)
 526 {
 527   struct GNUNET_CADET_Channel *channel;
 528
 529   send_next_msg_task = NULL;
 530   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending next message: %d\n", data_sent);
 531
 532   channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch;
 533   GNUNET_assert (NULL != channel);
 534   GNUNET_assert (SPEED == test);
 535   send_test_message (channel);
 536   if (data_sent < TOTAL_PACKETS)
 537   {
 538     /* SPEED test: Send all messages as soon as possible */
 539     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 540                 "Scheduling message %d\n",
 541                 data_sent + 1);
 542     send_next_msg_task =
 543         GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
 544                                      &send_next_msg,
 545                                      NULL);
 546   }
 547 }
 548
 549
 550 /**
 551  * Every few messages cancel the timeout task and re-schedule it again, to
 552  * avoid timing out when traffic keeps coming.
 553  *
 554  * @param line Code line number to log if a timeout occurs.
 555  */
 556 static void
 557 reschedule_timeout_task (long line)
 558 {
 559   if ((ok % 10) == 0)
 560   {
 561     if (NULL != disconnect_task)
 562     {
 563       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 564                   " reschedule timeout every 10 messages\n");
 565       GNUNET_SCHEDULER_cancel (disconnect_task);
 566       disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
 567                                                       &gather_stats_and_exit,
 568                                                       (void *) line);
 569     }
 570   }
 571 }
 572
 573
 574 /**
 575  * Check if payload is sane (size contains payload).
 576  *
 577  * @param cls should match #ch
 578  * @param message The actual message.
 579  * @return #GNUNET_OK to keep the channel open,
 580  *         #GNUNET_SYSERR to close it (signal serious error).
 581  */
 582 static int
 583 check_data (void *cls, const struct GNUNET_MessageHeader *message)
 584 {
 585   if (sizeof (struct GNUNET_MessageHeader) >= ntohs (message->size))
 586     return GNUNET_SYSERR;
 587   return GNUNET_OK;             /* all is well-formed */
 588 }
 589
 590
 591 /**
 592  * Function is called whenever a message is received.
 593  *
 594  * @param cls closure (set from GNUNET_CADET_connect(), peer number)
 595  * @param message the actual message
 596  */
 597 static void
 598 handle_data (void *cls, const struct GNUNET_MessageHeader *message)
 599 {
 600   struct CadetTestChannelWrapper *ch = cls;
 601   struct GNUNET_CADET_Channel *channel = ch->ch;
 602   uint32_t *data;
 603   uint32_t payload;
 604   int *counter;
 605
 606   ok++;
 607   counter = get_target_channel () == channel ? &data_received : &ack_received;
 608
 609   reschedule_timeout_task ((long) __LINE__);
 610
 611   if (channel == outgoing_ch)
 612   {
 613     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Root client got a message.\n");
 614   }
 615   else if (channel == incoming_ch)
 616   {
 617     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Leaf client got a message.\n");
 618   }
 619   else
 620   {
 621     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unknown channel %p.\n", channel);
 622     GNUNET_assert (0);
 623   }
 624
 625   GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: (%d/%d)\n", ok, ok_goal);
 626   data = (uint32_t *) &message[1];
 627   payload = ntohl (*data);
 628   if (payload == *counter)
 629   {
 630     GNUNET_log (GNUNET_ERROR_TYPE_INFO, " payload as expected: %u\n", payload);
 631   }
 632   else
 633   {
 634     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 635                 " payload %u, expected: %u\n",
 636                 payload, *counter);
 637   }
 638
 639   if (GNUNET_NO == initialized)
 640   {
 641     initialized = GNUNET_YES;
 642     start_time = GNUNET_TIME_absolute_get ();
 643     if (SPEED == test)
 644     {
 645       GNUNET_assert (incoming_ch == channel);
 646       send_next_msg_task = GNUNET_SCHEDULER_add_now (&send_next_msg, NULL);
 647       return;
 648     }
 649   }
 650
 651   (*counter)++;
 652   if (get_target_channel () == channel) /* Got "data" */
 653   {
 654     GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received);
 655     if (SPEED != test || (ok_goal - 2) == ok)
 656     {
 657       /* Send ACK */
 658       send_test_message (channel);
 659       return;
 660     }
 661     else
 662     {
 663       if (data_received < TOTAL_PACKETS)
 664         return;
 665     }
 666   }
 667   else /* Got "ack" */
 668   {
 669     if (SPEED_ACK == test || SPEED == test)
 670     {
 671       GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
 672       /* Send more data */
 673       send_test_message (channel);
 674       if (ack_received < TOTAL_PACKETS && SPEED != test)
 675         return;
 676       if (ok == 2 && SPEED == test)
 677         return;
 678       show_end_data ();
 679     }
 680     if (test == P2P_SIGNAL)
 681     {
 682       GNUNET_CADET_channel_destroy (incoming_ch);
 683       incoming_ch = NULL;
 684     }
 685     else
 686     {
 687       GNUNET_CADET_channel_destroy (outgoing_ch);
 688       outgoing_ch = NULL;
 689     }
 690   }
 691 }
 692
 693
 694 /**
 695  * Method called whenever a peer connects to a port in MQ-based CADET.
 696  *
 697  * @param cls Closure from #GNUNET_CADET_open_porT (peer # as long).
 698  * @param channel New handle to the channel.
 699  * @param source Peer that started this channel.
 700  * @return Closure for the incoming @a channel. It's given to:
 701  *         - The #GNUNET_CADET_DisconnectEventHandler (given to
 702  *           #GNUNET_CADET_open_porT) when the channel dies.
 703  *         - Each the #GNUNET_MQ_MessageCallback handlers for each message
 704  *           received on the @a channel.
 705  */
 706 static void *
 707 connect_handler (void *cls, struct GNUNET_CADET_Channel *channel,
 708                  const struct GNUNET_PeerIdentity *source)
 709 {
 710   struct CadetTestChannelWrapper *ch;
 711   long peer = (long) cls;
 712
 713   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 714               "Incoming channel from %s to %ld: %p\n",
 715               GNUNET_i2s (source), peer, channel);
 716   ok++;
 717   GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: %d\n", ok);
 718   if (peer == peers_requested - 1)
 719   {
 720     if (NULL != incoming_ch)
 721     {
 722       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 723                   "Duplicate incoming channel for client %lu\n", (long) cls);
 724       GNUNET_assert (0);
 725     }
 726     incoming_ch = channel;
 727   }
 728   else
 729   {
 730     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 731                 "Incoming channel for unexpected peer #%lu\n", (long) cls);
 732     GNUNET_assert (0);
 733   }
 734   if (NULL != disconnect_task)
 735   {
 736     GNUNET_SCHEDULER_cancel (disconnect_task);
 737     disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
 738                                                     &gather_stats_and_exit,
 739                                                     (void *) __LINE__);
 740   }
 741
 742   /* TODO: cannot return channel as-is, in order to unify the data handlers */
 743   ch = GNUNET_new (struct CadetTestChannelWrapper);
 744   ch->ch = channel;
 745
 746   return ch;
 747 }
 748
 749
 750 /**
 751  * Function called whenever an MQ-channel is destroyed, even if the destruction
 752  * was requested by #GNUNET_CADET_channel_destroy.
 753  * It must NOT call #GNUNET_CADET_channel_destroy on the channel.
 754  *
 755  * It should clean up any associated state, including cancelling any pending
 756  * transmission on this channel.
 757  *
 758  * @param cls Channel closure (channel wrapper).
 759  * @param channel Connection to the other end (henceforth invalid).
 760  */
 761 static void
 762 disconnect_handler (void *cls, const struct GNUNET_CADET_Channel *channel)
 763 {
 764   struct CadetTestChannelWrapper *ch_w = cls;
 765
 766   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Channel disconnected\n");
 767   GNUNET_assert (ch_w->ch == channel);
 768   if (channel == incoming_ch)
 769   {
 770     ok++;
 771     incoming_ch = NULL;
 772   }
 773   else if (outgoing_ch == channel
 774   )
 775   {
 776     if (P2P_SIGNAL == test)
 777     {
 778       ok++;
 779     }
 780     outgoing_ch = NULL;
 781   }
 782   else
 783     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unknown channel! %p\n", channel);
 784   GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: %d\n", ok);
 785
 786   if (NULL != disconnect_task)
 787   {
 788     GNUNET_SCHEDULER_cancel (disconnect_task);
 789     disconnect_task =
 790         GNUNET_SCHEDULER_add_now (&gather_stats_and_exit, (void *) __LINE__);
 791   }
 792 }
 793
 794
 795 /**
 796  * START THE TESTCASE ITSELF, AS WE ARE CONNECTED TO THE CADET SERVICES.
 797  *
 798  * Testcase continues when the root receives confirmation of connected peers,
 799  * on callback function ch.
 800  *
 801  * @param cls Closure (unused).
 802  */
 803 static void
 804 start_test (void *cls)
 805 {
 806   struct GNUNET_MQ_MessageHandler handlers[] = {
 807     GNUNET_MQ_hd_var_size (data,
 808                            GNUNET_MESSAGE_TYPE_DUMMY,
 809                            struct GNUNET_MessageHeader,
 810                            NULL),
 811     GNUNET_MQ_handler_end ()
 812   };
 813   struct CadetTestChannelWrapper *ch;
 814   enum GNUNET_CADET_ChannelOption flags;
 815
 816   test_task = NULL;
 817   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "start_test\n");
 818   if (NULL != disconnect_task)
 819   {
 820     GNUNET_SCHEDULER_cancel (disconnect_task);
 821     disconnect_task = NULL;
 822   }
 823
 824   flags = GNUNET_CADET_OPTION_DEFAULT;
 825   if (SPEED_REL == test)
 826   {
 827     test = SPEED;
 828     flags |= GNUNET_CADET_OPTION_RELIABLE;
 829   }
 830
 831   ch = GNUNET_new (struct CadetTestChannelWrapper);
 832   outgoing_ch = GNUNET_CADET_channel_creatE (h1,
 833                                              ch,
 834                                              p_id[1],
 835                                              &port,
 836                                              flags,
 837                                              NULL,
 838                                              &disconnect_handler,
 839                                              handlers);
 840
 841   ch->ch = outgoing_ch;
 842
 843   disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
 844                                                   &gather_stats_and_exit,
 845                                                   (void *) __LINE__);
 846   if (KEEPALIVE == test)
 847     return;                     /* Don't send any data. */
 848
 849
 850   data_received = 0;
 851   data_sent = 0;
 852   ack_received = 0;
 853   ack_sent = 0;
 854   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 855               "Sending data initializer on channel %p...\n",
 856               outgoing_ch);
 857   send_test_message (outgoing_ch);
 858 }
 859
 860
 861 /**
 862  * Callback to be called when the requested peer information is available
 863  *
 864  * @param cls the closure from GNUNET_TESTBED_peer_get_information()
 865  * @param op the operation this callback corresponds to
 866  * @param pinfo the result; will be NULL if the operation has failed
 867  * @param emsg error message if the operation has failed;
 868  *             NULL if the operation is successfull
 869  */
 870 static void
 871 pi_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
 872        const struct GNUNET_TESTBED_PeerInformation *pinfo, const char *emsg)
 873 {
 874   long i = (long) cls;
 875
 876   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ID callback for %ld\n", i);
 877
 878   if ((NULL == pinfo) || (NULL != emsg))
 879   {
 880     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "pi_cb: %s\n", emsg);
 881     abort_test (__LINE__);
 882     return;
 883   }
 884   p_id[i] = pinfo->result.id;
 885   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  id: %s\n", GNUNET_i2s (p_id[i]));
 886   p_ids++;
 887   if (p_ids < 2)
 888     return;
 889   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got all IDs, starting test\n");
 890   test_task = GNUNET_SCHEDULER_add_now (&start_test, NULL);
 891 }
 892
 893
 894 /**
 895  * test main: start test when all peers are connected
 896  *
 897  * @param cls Closure.
 898  * @param ctx Argument to give to GNUNET_CADET_TEST_cleanup on test end.
 899  * @param num_peers Number of peers that are running.
 900  * @param peers Array of peers.
 901  * @param cadets Handle to each of the CADETs of the peers.
 902  */
 903 static void
 904 tmain (void *cls,
 905        struct GNUNET_CADET_TEST_Context *ctx,
 906        unsigned int num_peers,
 907        struct GNUNET_TESTBED_Peer **peers,
 908        struct GNUNET_CADET_Handle **cadets)
 909 {
 910   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test main\n");
 911   ok = 0;
 912   test_ctx = ctx;
 913   peers_running = num_peers;
 914   GNUNET_assert (peers_running == peers_requested);
 915   testbed_peers = peers;
 916   h1 = cadets[0];
 917   h2 = cadets[num_peers - 1];
 918   disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
 919                                                   &disconnect_cadet_peers,
 920                                                   (void *) __LINE__);
 921   GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 922   t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
 923                                                  GNUNET_TESTBED_PIT_IDENTITY,
 924                                                  &pi_cb,
 925                                                  (void *) 0L);
 926   t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1],
 927                                                  GNUNET_TESTBED_PIT_IDENTITY,
 928                                                  &pi_cb,
 929                                                  (void *) 1L);
 930   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n");
 931 }
 932
 933
 934 /**
 935  * Main: start test
 936  */
 937 int
 938 main (int argc, char *argv[])
 939 {
 940   struct GNUNET_MQ_MessageHandler handlers[] = {
 941     GNUNET_MQ_hd_var_size (data,
 942                            GNUNET_MESSAGE_TYPE_DUMMY,
 943                            struct GNUNET_MessageHeader,
 944                            NULL),
 945     GNUNET_MQ_handler_end ()
 946   };
 947
 948   initialized = GNUNET_NO;
 949   static const struct GNUNET_HashCode *ports[2];
 950   const char *config_file;
 951   char port_id[] = "test port";
 952
 953   GNUNET_CRYPTO_hash (port_id, sizeof (port_id), &port);
 954
 955   GNUNET_log_setup ("test", "DEBUG", NULL);
 956   config_file = "test_cadet.conf";
 957
 958   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start\n");
 959
 960   /* Find out requested size */
 961   if (strstr (argv[0], "_2_") != NULL)
 962   {
 963     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n");
 964     peers_requested = 2;
 965   }
 966   else if (strstr (argv[0], "_5_") != NULL)
 967   {
 968     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n");
 969     peers_requested = 5;
 970   }
 971   else
 972   {
 973     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n");
 974     peers_requested = 2;
 975   }
 976
 977   /* Find out requested test */
 978   if (strstr (argv[0], "_forward") != NULL)
 979   {
 980     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n");
 981     test = FORWARD;
 982     test_name = "unicast";
 983     ok_goal = 4;
 984   }
 985   else if (strstr (argv[0], "_signal") != NULL)
 986   {
 987     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n");
 988     test = P2P_SIGNAL;
 989     test_name = "signal";
 990     ok_goal = 4;
 991   }
 992   else if (strstr (argv[0], "_speed_ack") != NULL)
 993   {
 994     /* Test is supposed to generate the following callbacks:
 995      * 1 incoming channel (@dest)
 996      * TOTAL_PACKETS received data packet (@dest)
 997      * TOTAL_PACKETS received data packet (@orig)
 998      * 1 received channel destroy (@dest)
 999      */
1000     ok_goal = TOTAL_PACKETS * 2 + 2;
1001     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n");
1002     test = SPEED_ACK;
1003     test_name = "speed ack";
1004   }
1005   else if (strstr (argv[0], "_speed") != NULL)
1006   {
1007     /* Test is supposed to generate the following callbacks:
1008      * 1 incoming channel (@dest)
1009      * 1 initial packet (@dest)
1010      * TOTAL_PACKETS received data packet (@dest)
1011      * 1 received data packet (@orig)
1012      * 1 received channel destroy (@dest)
1013      */
1014     ok_goal = TOTAL_PACKETS + 4;
1015     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
1016     if (strstr (argv[0], "_reliable") != NULL)
1017     {
1018       test = SPEED_REL;
1019       test_name = "speed reliable";
1020       config_file = "test_cadet_drop.conf";
1021     }
1022     else
1023     {
1024       test = SPEED;
1025       test_name = "speed";
1026     }
1027   }
1028   else if (strstr (argv[0], "_keepalive") != NULL)
1029   {
1030     test = KEEPALIVE;
1031     /* Test is supposed to generate the following callbacks:
1032      * 1 incoming channel (@dest)
1033      * [wait]
1034      * 1 received channel destroy (@dest)
1035      */
1036     ok_goal = 2;
1037   }
1038   else
1039   {
1040     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n");
1041     test = SETUP;
1042     ok_goal = 0;
1043   }
1044
1045   if (strstr (argv[0], "backwards") != NULL)
1046   {
1047     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n");
1048     test_backwards = GNUNET_YES;
1049     GNUNET_asprintf (&test_name, "backwards %s", test_name);
1050   }
1051
1052   p_ids = 0;
1053   ports[0] = &port;
1054   ports[1] = NULL;
1055   GNUNET_CADET_TEST_ruN ("test_cadet_small",
1056                          config_file,
1057                          peers_requested,
1058                          &tmain,
1059                          NULL,        /* tmain cls */
1060                          &connect_handler,
1061                          NULL,
1062                          &disconnect_handler,
1063                          handlers,
1064                          ports);
1065   if (NULL != strstr (argv[0], "_reliable"))
1066     msg_dropped = 0;            /* dropped should be retransmitted */
1067
1068   if (ok_goal > ok - msg_dropped)
1069   {
1070     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal);
1071     return 1;
1072   }
1073   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "success\n");
1074   return 0;
1075 }
1076
1077 /* end of test_cadet.c */