src/transport/test_quota_compliance.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file transport/test_quota_compliance.c
  22  * @brief base test case for transport implementations
  23  *
  24  * This test case tests quota compliance both on core and transport level
  25  */
  26 #include "platform.h"
  27 #include "gnunet_common.h"
  28 #include "gnunet_hello_lib.h"
  29 #include "gnunet_getopt_lib.h"
  30 #include "gnunet_os_lib.h"
  31 #include "gnunet_program_lib.h"
  32 #include "gnunet_scheduler_lib.h"
  33 #include "gnunet_server_lib.h"
  34 #include "gnunet_transport_service.h"
  35 #include "transport.h"
  36 #include "transport-testing.h"
  37
  38 #define VERBOSE GNUNET_NO
  39
  40 #define VERBOSE_ARM GNUNET_NO
  41
  42 #define START_ARM GNUNET_YES
  43 #define DEBUG_MEASUREMENT GNUNET_NO
  44 #define DEBUG_CONNECTIONS GNUNET_NO
  45
  46 #define MEASUREMENT_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  47 #define MEASUREMENT_MSG_SIZE 1024
  48 #define MEASUREMENT_MSG_SIZE_BIG 32768
  49 #define MEASUREMENT_MAX_QUOTA 1024 * 1024 * 1024
  50 #define MEASUREMENT_MIN_QUOTA 1024
  51 #define SEND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
  52 #define MEASUREMENT_SOFT_LIMIT 1024
  53
  54 /**
  55  * Testcase timeout
  56  */
  57 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 200)
  58
  59
  60
  61 #define MTYPE 11111
  62
  63 /**
  64  * Handle for a transmission-ready request.
  65  */
  66 struct GNUNET_TRANSPORT_TransmitHandle
  67 {
  68
  69   /**
  70    * Neighbour for this handle, NULL for control-traffic.
  71    */
  72   struct NeighbourList *neighbour;
  73
  74   /**
  75    * Function to call when notify_size bytes are available
  76    * for transmission.
  77    */
  78   GNUNET_CONNECTION_TransmitReadyNotify notify;
  79
  80   /**
  81    * Closure for notify.
  82    */
  83   void *notify_cls;
  84
  85   /**
  86    * transmit_ready task Id.  The task is used to introduce the
  87    * artificial delay that may be required to maintain the bandwidth
  88    * limits.  Later, this will be the ID of the "transmit_timeout"
  89    * task which is used to signal a timeout if the transmission could
  90    * not be done in a timely fashion.
  91    */
  92   GNUNET_SCHEDULER_TaskIdentifier notify_delay_task;
  93
  94   /**
  95    * Timeout for this request.
  96    */
  97   struct GNUNET_TIME_Absolute timeout;
  98
  99   /**
 100    * How many bytes is our notify callback waiting for?
 101    */
 102   size_t notify_size;
 103
 104   /**
 105    * How important is this message?
 106    */
 107   unsigned int priority;
 108
 109 };
 110
 111 static struct PeerContext p1;
 112
 113 static struct PeerContext p2;
 114
 115 static int ok;
 116
 117 static int connected;
 118 static int measurement_running;
 119 static int send_running;
 120 static int recv_running;
 121
 122 static unsigned long long total_bytes_sent;
 123 static unsigned long long last_msg_sent;
 124 static unsigned long long last_msg_recv;
 125 static unsigned long long current_quota_p1;
 126 static unsigned long long current_quota_p2;
 127
 128 static int is_tcp;
 129 static int is_tcp_nat;
 130 static int is_http;
 131 static int is_https;
 132 static int is_udp;
 133 static int is_unix;
 134 static int is_asymmetric_send_constant;
 135 static int is_asymmetric_recv_constant;
 136
 137 static struct GNUNET_TIME_Absolute start_time;
 138
 139 static GNUNET_SCHEDULER_TaskIdentifier die_task;
 140 static GNUNET_SCHEDULER_TaskIdentifier tct;
 141 static GNUNET_SCHEDULER_TaskIdentifier measurement_task;
 142 static GNUNET_SCHEDULER_TaskIdentifier measurement_counter_task;
 143
 144 static struct GNUNET_TRANSPORT_TransmitHandle * transmit_handle;
 145
 146 #define OKPP do { ok++; } while (0)
 147
 148
 149 static void
 150 end ()
 151 {
 152   GNUNET_SCHEDULER_cancel (die_task);
 153   die_task = GNUNET_SCHEDULER_NO_TASK;
 154
 155   if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
 156     {
 157       GNUNET_SCHEDULER_cancel (measurement_task);
 158       measurement_task = GNUNET_SCHEDULER_NO_TASK;
 159     }
 160   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
 161     {
 162       GNUNET_SCHEDULER_cancel (measurement_counter_task);
 163       measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
 164     }
 165   fprintf(stderr,"\n");
 166   GNUNET_SCHEDULER_shutdown ();
 167 #if DEBUG_CONNECTIONS
 168   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 169               "Disconnecting from transports!\n");
 170 #endif
 171   GNUNET_TRANSPORT_disconnect (p1.th);
 172   GNUNET_TRANSPORT_disconnect (p2.th);
 173 #if DEBUG_CONNECTIONS
 174   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 175               "Transports disconnected, returning success!\n");
 176 #endif
 177   GNUNET_SCHEDULER_shutdown ();
 178 }
 179
 180
 181
 182 static void
 183 stop_arm (struct PeerContext *p)
 184 {
 185 #if START_ARM
 186   if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
 187     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 188   GNUNET_OS_process_wait (p->arm_proc);
 189   GNUNET_OS_process_close (p->arm_proc);
 190   p->arm_proc = NULL;
 191 #endif
 192   GNUNET_CONFIGURATION_destroy (p->cfg);
 193 }
 194
 195
 196 static void
 197 end_badly (void *cls,
 198            const struct GNUNET_SCHEDULER_TaskContext *tc)
 199 {
 200   if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
 201   {
 202     GNUNET_SCHEDULER_cancel (measurement_task);
 203     measurement_task = GNUNET_SCHEDULER_NO_TASK;
 204   }
 205   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
 206     {
 207       GNUNET_SCHEDULER_cancel (measurement_counter_task);
 208       measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
 209     }
 210   GNUNET_break (0);
 211   if (GNUNET_SCHEDULER_NO_TASK != tct)
 212     {
 213       GNUNET_SCHEDULER_cancel (tct);
 214       tct = GNUNET_SCHEDULER_NO_TASK;
 215     }
 216   if (p1.th != NULL)
 217     GNUNET_TRANSPORT_disconnect (p1.th);
 218   if (p2.th != NULL)
 219     GNUNET_TRANSPORT_disconnect (p2.th);
 220   ok = 1;
 221 }
 222
 223 struct TestMessage
 224 {
 225   struct GNUNET_MessageHeader header;
 226   uint32_t num;
 227 };
 228
 229
 230 static unsigned int
 231 get_size ()
 232 {
 233   return MEASUREMENT_MSG_SIZE + sizeof (struct TestMessage);
 234 }
 235
 236 static void
 237 notify_receive_new (void *cls,
 238                 const struct GNUNET_PeerIdentity *peer,
 239                 const struct GNUNET_MessageHeader *message,
 240                 const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
 241 {
 242   const struct TestMessage *hdr;
 243
 244   GNUNET_assert (message != NULL);
 245   hdr = (const struct TestMessage*) message;
 246   if (measurement_running == GNUNET_NO)
 247           return;
 248   if (MTYPE != ntohs (message->type))
 249     return;
 250
 251 #if DEBUG_MEASUREMENT
 252   if (ntohl(hdr->num) % 5000 == 0)
 253     {
 254       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 255                   "Got message %u of size %u\n",
 256                   ntohl (hdr->num),
 257                   ntohs (message->size));
 258     }
 259 #endif
 260   /*
 261   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 262               "Got message %u\n",
 263               ntohl (hdr->num));*/
 264   last_msg_recv = ntohl (hdr->num);
 265 }
 266
 267
 268 static size_t
 269 notify_ready (void *cls, size_t size, void *buf)
 270 {
 271   char *cbuf = buf;
 272   struct TestMessage hdr;
 273   unsigned int s;
 274   unsigned int ret;
 275
 276   transmit_handle = NULL;
 277   if (measurement_task == GNUNET_SCHEDULER_NO_TASK)
 278     return 0;
 279
 280   if (buf == NULL)
 281     {
 282       ok = 42;
 283       return 0;
 284     }
 285   if (measurement_running != GNUNET_YES)
 286     {
 287       send_running = GNUNET_NO;
 288       return 0;
 289     }
 290   send_running = GNUNET_YES;
 291   ret = 0;
 292   s = get_size ();
 293   GNUNET_assert (size >= s);
 294   GNUNET_assert (buf != NULL);
 295   last_msg_sent++;
 296   cbuf = buf;
 297   do
 298     {
 299       hdr.header.size = htons (s);
 300       hdr.header.type = htons (MTYPE);
 301       hdr.num = htonl (last_msg_sent);
 302       memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
 303       ret += sizeof (struct TestMessage);
 304       memset (&cbuf[ret], last_msg_sent, s - sizeof (struct TestMessage));
 305       ret += s - sizeof (struct TestMessage);
 306 #if DEBUG_MEASUREMENT
 307       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 308                   "Sending message %u\n",
 309                   last_msg_sent);
 310 #endif
 311       s = get_size ();
 312       if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
 313         break; /* sometimes pack buffer full, sometimes not */
 314     }
 315   while (size - ret >= s);
 316   transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
 317                                             &p1.id,
 318                                             s, 0, SEND_TIMEOUT,
 319                                             &notify_ready,
 320                                             NULL);
 321   total_bytes_sent += s;
 322   return ret;
 323 }
 324
 325
 326 static void
 327 measure (unsigned long long quota_p1, unsigned long long quota_p2);
 328
 329 static void
 330 measurement_counter (void *cls,
 331                      const struct GNUNET_SCHEDULER_TaskContext *tc)
 332 {
 333   measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
 334   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 335     return;
 336
 337   fprintf(stderr,".");
 338   measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 339                                                            &measurement_counter,
 340                                                            NULL);
 341 }
 342
 343
 344 static void
 345 measurement_end (void *cls,
 346                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 347 {
 348   static int strike_counter;
 349   static int failed_measurement_counter = 1;
 350   unsigned long long  quota_allowed = 0;
 351   int delta = 0;
 352
 353   measurement_task  = GNUNET_SCHEDULER_NO_TASK;
 354   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 355     return;
 356
 357   measurement_running = GNUNET_NO;
 358   struct GNUNET_TIME_Relative duration
 359     = GNUNET_TIME_absolute_get_difference(start_time, GNUNET_TIME_absolute_get());
 360
 361
 362   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
 363     {
 364       GNUNET_SCHEDULER_cancel (measurement_counter_task);
 365       measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
 366     }
 367
 368   if (transmit_handle != NULL)
 369     {
 370       GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
 371       transmit_handle = NULL;
 372     }
 373
 374   if (current_quota_p1 < current_quota_p2)
 375     quota_allowed = current_quota_p1;
 376   else
 377     quota_allowed = current_quota_p2;
 378
 379
 380   if (MEASUREMENT_SOFT_LIMIT > (quota_allowed/3))
 381     delta = MEASUREMENT_SOFT_LIMIT;
 382   else
 383     delta = (quota_allowed/3);
 384
 385   /* Throughput is far too slow. This is to prevent the test to exit with success when throughput is 0 */
 386   if ((total_bytes_sent/(duration.rel_value / 1000)) < 100)
 387     {
 388       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 389                   "\nQuota compliance failed: \n"                       \
 390                   "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 391                   "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 392                   "Throughput              : %10llu kB/s (%llu B/s)\n",
 393                   (quota_allowed / (1024)), quota_allowed,
 394                   ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
 395                   (total_bytes_sent/(duration.rel_value / 1000)/1024),
 396                   total_bytes_sent/(duration.rel_value / 1000));
 397       ok = 1;
 398       failed_measurement_counter--;
 399       if (failed_measurement_counter < 0)
 400         {
 401           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 402                       "\nQuota measurement failed and no free strike: %i\n",
 403                       failed_measurement_counter);
 404           end();
 405           return;
 406         }
 407       else
 408         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 409                     "\nQuota measurement failed and %i free strikes\n",
 410                     failed_measurement_counter);
 411     }
 412
 413   /* Throughput is bigger than allowed quota + some extra*/
 414   if ((total_bytes_sent/(duration.rel_value / 1000)) > (quota_allowed + delta))
 415     {
 416       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 417                   "\nQuota compliance failed: \n"                       \
 418                   "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 419                   "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 420                   "Throughput              : %10llu kB/s (%llu B/s)\n",
 421                   (quota_allowed / (1024)), quota_allowed,
 422                   ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
 423                   (total_bytes_sent/(duration.rel_value / 1000)/1024),
 424                   total_bytes_sent/(duration.rel_value / 1000));
 425       ok = 1;
 426       failed_measurement_counter--;
 427       if (failed_measurement_counter < 0)
 428         {
 429           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 430                       "\nQuota measurement failed and no free strike: %i\n",failed_measurement_counter);
 431           end();
 432           return;
 433         }
 434       else
 435         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 436                     "\nQuota measurement failed and %i free strikes\n",failed_measurement_counter);
 437     }
 438   else
 439     {
 440       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 441                   "\nQuota compliance ok: \n"                   \
 442                   "Quota allowed: %10llu kB/s\n"                        \
 443                   "Throughput   : %10llu kB/s\n",
 444                   (quota_allowed / (1024)),
 445                   (total_bytes_sent/(duration.rel_value / 1000)/1024));
 446       if (failed_measurement_counter < 2)
 447         failed_measurement_counter++;
 448       ok = 0;
 449     }
 450
 451   if ((quota_allowed) > (2 *(total_bytes_sent/(duration.rel_value / 1000))))
 452     {
 453       if (failed_measurement_counter < 2)
 454         failed_measurement_counter++;
 455       if (strike_counter == 2)
 456         {
 457           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 458                       "Maximum transmission rate reached, stopping test\n");
 459           end();
 460           return;
 461         }
 462     }
 463   else
 464     {
 465       strike_counter = 0;
 466     }
 467
 468   if (quota_allowed == MEASUREMENT_MAX_QUOTA)
 469     {
 470       end();
 471       return;
 472     }
 473   if (is_asymmetric_send_constant == GNUNET_YES)
 474     {
 475       if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
 476         measure (current_quota_p1 * 2, MEASUREMENT_MAX_QUOTA);
 477       else
 478         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
 479     }
 480   else if (is_asymmetric_recv_constant == GNUNET_YES)
 481     {
 482       if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
 483         measure (MEASUREMENT_MAX_QUOTA, current_quota_p2 * 2);
 484       else
 485         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
 486     }
 487   else
 488     {
 489       if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
 490         measure ((current_quota_p1) * 2, (current_quota_p2) * 2);
 491       else
 492         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
 493     }
 494 }
 495
 496 static void
 497 measure (unsigned long long quota_p1, unsigned long long quota_p2)
 498 {
 499   current_quota_p1 = quota_p1;
 500   current_quota_p2 = quota_p2;
 501 #if VERBOSE
 502   if ((is_asymmetric_send_constant == GNUNET_YES) || (is_asymmetric_recv_constant == GNUNET_YES))
 503     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 504                 "Starting transport level measurement for %u seconds, receiving peer quota %llu kB/s, sending peer quota %llu kB/s\n",
 505                 MEASUREMENT_INTERVALL.rel_value / 1000 ,
 506                 current_quota_p1 / 1024,
 507                 current_quota_p2 / 1024);
 508   else
 509     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 510                 "Starting transport level measurement for %u seconds, symmetric quota %llu kB/s\n",
 511                 MEASUREMENT_INTERVALL.rel_value / 1000,
 512                 current_quota_p2 / 1024);
 513
 514 #endif
 515   GNUNET_TRANSPORT_set_quota (p1.th,
 516                               &p2.id,
 517                               GNUNET_BANDWIDTH_value_init (current_quota_p1),
 518                               GNUNET_BANDWIDTH_value_init (current_quota_p1));
 519   GNUNET_TRANSPORT_set_quota (p2.th,
 520                               &p1.id,
 521                               GNUNET_BANDWIDTH_value_init (current_quota_p2),
 522                               GNUNET_BANDWIDTH_value_init (current_quota_p2));
 523   GNUNET_SCHEDULER_cancel (die_task);
 524   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 525                                            &end_badly,
 526                                            NULL);
 527   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
 528     GNUNET_SCHEDULER_cancel (measurement_counter_task);
 529   measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 530                                                            &measurement_counter,
 531                                                            NULL);
 532   measurement_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
 533                                                    &measurement_end,
 534                                                    NULL);
 535   total_bytes_sent = 0;
 536   last_msg_sent = 0;
 537   last_msg_recv = 0;
 538   measurement_running = GNUNET_YES;
 539   start_time = GNUNET_TIME_absolute_get ();
 540
 541   if (transmit_handle != NULL)
 542     GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
 543   transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
 544                                                             &p1.id,
 545                                                             get_size (), 0, SEND_TIMEOUT,
 546                                                             &notify_ready,
 547                                                             NULL);
 548 }
 549
 550
 551 static void
 552 exchange_hello_last (void *cls,
 553                      const struct GNUNET_MessageHeader *message)
 554 {
 555   struct PeerContext *me = cls;
 556
 557   GNUNET_assert (message != NULL);
 558 #if DEBUG_CONNECTIONS
 559   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 560               "Exchanging HELLO of size %d with peer (%s)!\n",
 561               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
 562               GNUNET_i2s (&me->id));
 563 #endif
 564   GNUNET_assert (GNUNET_OK ==
 565                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
 566                                       message, &me->id));
 567   GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
 568 }
 569
 570
 571
 572 static void
 573 exchange_hello (void *cls,
 574                 const struct GNUNET_MessageHeader *message)
 575 {
 576   struct PeerContext *me = cls;
 577
 578   GNUNET_assert (message != NULL);
 579   GNUNET_assert (GNUNET_OK ==
 580                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
 581                                       message, &me->id));
 582 #if DEBUG_CONNECTIONS
 583   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 584               "Exchanging HELLO of size %d from peer %s!\n",
 585               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
 586               GNUNET_i2s (&me->id));
 587 #endif
 588   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 589 }
 590
 591
 592 static void
 593 notify_connect (void *cls,
 594                 const struct GNUNET_PeerIdentity *peer,
 595                 const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
 596 {
 597   connected++;
 598  if (cls == &p1)
 599     {
 600 #if DEBUG_CONNECTIONS
 601       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 602                   "Peer 1 `%4s' connected to us (%p)!\n",
 603                   GNUNET_i2s (peer),
 604                   cls);
 605 #endif
 606     }
 607   else
 608     {
 609 #if DEBUG_CONNECTIONS
 610       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 611                   "Peer 2 `%4s' connected to us (%p)!\n",
 612                   GNUNET_i2s (peer),
 613                   cls);
 614 #endif
 615     }
 616   if (connected == 2)
 617     {
 618       GNUNET_SCHEDULER_cancel (tct);
 619       tct = GNUNET_SCHEDULER_NO_TASK;
 620       GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
 621       GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
 622       if (is_asymmetric_send_constant == GNUNET_YES)
 623         measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MAX_QUOTA);
 624       else if (is_asymmetric_recv_constant == GNUNET_YES)
 625         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MIN_QUOTA);
 626       else
 627         measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MIN_QUOTA);
 628     }
 629 }
 630
 631
 632 static void
 633 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 634 {
 635   connected--;
 636 #if DEBUG_CONNECTIONS
 637   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 638               "Peer `%4s' disconnected (%p)!\n",
 639               GNUNET_i2s (peer), cls);
 640 #endif
 641 }
 642
 643
 644 static void
 645 setup_peer (struct PeerContext *p, const char *cfgname)
 646 {
 647   p->cfg = GNUNET_CONFIGURATION_create ();
 648   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 649   if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
 650     {
 651       GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
 652       GNUNET_DISK_directory_remove (p->servicehome);
 653     }
 654
 655 #if START_ARM
 656   p->arm_proc = GNUNET_OS_start_process (NULL, NULL,
 657                                         "gnunet-service-arm",
 658                                         "gnunet-service-arm",
 659 #if VERBOSE_ARM
 660                                         "-L", "DEBUG",
 661 #endif
 662                                         "-c", cfgname, NULL);
 663 #endif
 664
 665   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
 666                                     p,
 667                                     &notify_receive_new,
 668                                     &notify_connect,
 669                                     &notify_disconnect);
 670   GNUNET_assert (p->th != NULL);
 671 }
 672
 673
 674 static void
 675 try_connect (void *cls,
 676              const struct GNUNET_SCHEDULER_TaskContext *tc)
 677 {
 678 #if DEBUG_CONNECTIONS
 679   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 680               "Asking peers to connect...\n");
 681 #endif
 682   GNUNET_TRANSPORT_try_connect (p2.th,
 683                                 &p1.id);
 684   GNUNET_TRANSPORT_try_connect (p1.th,
 685                                 &p2.id);
 686   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 687                                       &try_connect,
 688                                       NULL);
 689 }
 690
 691
 692 static void
 693 run (void *cls,
 694      char *const *args,
 695      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 696 {
 697   GNUNET_assert (ok == 1);
 698   OKPP;
 699
 700   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 701                                            &end_badly,
 702                                            NULL);
 703   measurement_running = GNUNET_NO;
 704   send_running = GNUNET_NO;
 705   recv_running = GNUNET_NO;
 706
 707   if (is_tcp)
 708     {
 709       if (is_asymmetric_recv_constant == GNUNET_YES)
 710         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 711                     "Testing asymmetric quota compliance (receiver quota constant) for TCP transport plugin\n");
 712       else if (is_asymmetric_send_constant == GNUNET_YES)
 713         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 714                     "Testing asymmetric quota compliance (sender quota constant) for TCP transport plugin\n");
 715       else
 716         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 717                     "Testing symmetric quota compliance for TCP transport plugin\n");
 718       setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
 719       setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
 720     }
 721   else if (is_http)
 722     {
 723       if (is_asymmetric_recv_constant == GNUNET_YES)
 724         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 725                     "Testing asymmetric quota compliance (receiver quota constant) for HTTP transport plugin\n");
 726       else if (is_asymmetric_send_constant == GNUNET_YES)
 727         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 728                     "Testing asymmetric quota compliance (sender quota constant) for HTTP transport plugin\n");
 729       else
 730         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 731                     "Testing symmetric quota compliance for HTTP transport plugin\n");
 732       setup_peer (&p1, "test_quota_compliance_http_peer1.conf");
 733       setup_peer (&p2, "test_quota_compliance_http_peer2.conf");
 734     }
 735   else if (is_https)
 736     {
 737       if (is_asymmetric_recv_constant == GNUNET_YES)
 738         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 739                     "Testing asymmetric quota compliance (receiver quota constant) for HTTPS transport plugin\n");
 740       else if (is_asymmetric_send_constant == GNUNET_YES)
 741         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 742                     "Testing asymmetric quota compliance (sender quota constant) for HTTPS transport plugin\n");
 743       else
 744         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 745                     "Testing symmetric quota compliance for HTTPS transport plugin\n");
 746       setup_peer (&p1, "test_quota_compliance_https_peer1.conf");
 747       setup_peer (&p2, "test_quota_compliance_https_peer2.conf");
 748     }
 749   else if (is_udp)
 750     {
 751       if (is_asymmetric_recv_constant == GNUNET_YES)
 752         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 753                     "Testing asymmetric quota compliance (receiver quota constant) for UDP transport plugin\n");
 754       else if (is_asymmetric_send_constant == GNUNET_YES)
 755         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 756                     "Testing asymmetric quota compliance (sender quota constant) for UDP transport plugin\n");
 757       else
 758         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 759                     "Testing symmetric quota compliance for UDP transport plugin\n");
 760       setup_peer (&p1, "test_quota_compliance_udp_peer1.conf");
 761       setup_peer (&p2, "test_quota_compliance_udp_peer2.conf");
 762     }
 763   else if (is_unix)
 764     {
 765       if (is_asymmetric_recv_constant == GNUNET_YES)
 766         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 767                     "Testing asymmetric quota compliance (receiver quota constant) for UNIX transport plugin\n");
 768       else if (is_asymmetric_send_constant == GNUNET_YES)
 769         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 770                     "Testing asymmetric quota compliance (sender quota constant) for UNIX transport plugin\n");
 771       else
 772         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 773                     "Testing symmetric quota compliance for UNIX transport plugin\n");
 774       setup_peer (&p1, "test_quota_compliance_unix_peer1.conf");
 775       setup_peer (&p2, "test_quota_compliance_unix_peer2.conf");
 776     }
 777   else if (is_tcp_nat)
 778     {
 779       if (is_asymmetric_recv_constant == GNUNET_YES)
 780         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 781                     "Testing asymmetric quota compliance (receiver quota constant) for TCP NAT transport plugin\n");
 782       else if (is_asymmetric_send_constant == GNUNET_YES)
 783         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 784                     "Testing asymmetric quota compliance (sender quota constant) for TCP NAT transport plugin\n");
 785       else
 786         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 787                     "Testing symmetric quota compliance for TCP NAT transport plugin\n");
 788       setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
 789       setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
 790     }
 791   else
 792     GNUNET_assert (0);
 793
 794   GNUNET_assert(p1.th != NULL);
 795   GNUNET_assert(p2.th != NULL);
 796   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
 797   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
 798   tct = GNUNET_SCHEDULER_add_now (&try_connect, NULL);
 799 }
 800
 801
 802 int
 803 main (int argc, char *argv[])
 804 {
 805   int ret = 0;
 806   if (strstr(argv[0], "tcp_nat") != NULL)
 807     {
 808       is_tcp_nat = GNUNET_YES;
 809     }
 810   else if (strstr(argv[0], "tcp") != NULL)
 811     {
 812       is_tcp = GNUNET_YES;
 813     }
 814   else if (strstr(argv[0], "https") != NULL)
 815     {
 816       is_https = GNUNET_YES;
 817     }
 818   else if (strstr(argv[0], "http") != NULL)
 819     {
 820       is_http = GNUNET_YES;
 821     }
 822   else if (strstr(argv[0], "udp") != NULL)
 823     {
 824       is_udp = GNUNET_YES;
 825     }
 826   else if (strstr(argv[0], "unix") != NULL)
 827     {
 828       is_unix = GNUNET_YES;
 829     }
 830
 831   if (strstr(argv[0], "asymmetric_recv") != NULL)
 832   {
 833     is_asymmetric_recv_constant = GNUNET_YES;
 834   }
 835   else
 836     is_asymmetric_recv_constant = GNUNET_NO;
 837   if (strstr(argv[0], "asymmetric_send") != NULL)
 838     {
 839       is_asymmetric_send_constant = GNUNET_YES;
 840     }
 841   else
 842     is_asymmetric_send_constant = GNUNET_NO;
 843
 844   char * logger;
 845   if (is_tcp == GNUNET_YES)
 846     {
 847       if (is_asymmetric_recv_constant == GNUNET_YES)
 848         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_recv_constant");
 849       else if (is_asymmetric_send_constant == GNUNET_YES)
 850         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_send_constant");
 851       else
 852         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","symmetric");
 853     }
 854   else if (is_udp == GNUNET_YES)
 855     {
 856       if (is_asymmetric_recv_constant == GNUNET_YES)
 857         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_recv_constant");
 858       else if (is_asymmetric_send_constant == GNUNET_YES)
 859         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_send_constant");
 860       else
 861         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","symmetric");
 862     }
 863   else if (is_unix == GNUNET_YES)
 864     {
 865       if (is_asymmetric_recv_constant == GNUNET_YES)
 866         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_recv_constant");
 867       else if (is_asymmetric_send_constant == GNUNET_YES)
 868         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_send_constant");
 869       else
 870         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","symmetric");
 871     }
 872   else if (is_http == GNUNET_YES)
 873     {
 874       if (is_asymmetric_recv_constant == GNUNET_YES)
 875         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_recv_constant");
 876       else if (is_asymmetric_send_constant == GNUNET_YES)
 877         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_send_constant");
 878       else
 879         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","symmetric");
 880     }
 881   else if (is_https == GNUNET_YES)
 882     {
 883       if (is_asymmetric_recv_constant == GNUNET_YES)
 884         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_recv_constant");
 885       else if (is_asymmetric_send_constant == GNUNET_YES)
 886         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_send_constant");
 887       else
 888         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","symmetric");
 889     }
 890   else
 891     {
 892       GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","noplugin","none");
 893     }
 894
 895   fprintf(stderr,  "Running `%s'\n", logger);
 896   GNUNET_log_setup ("test-quota-compliance",
 897 #if VERBOSE
 898                     "DEBUG",
 899 #else
 900                     "WARNING",
 901 #endif
 902                     NULL);
 903   char *const argv1[] = { "test-quota-compliance",
 904     "-c",
 905     "test_quota_compliance_data.conf",
 906 #if VERBOSE
 907     "-L", "DEBUG",
 908 #endif
 909     NULL
 910   };
 911   struct GNUNET_GETOPT_CommandLineOption options[] = {
 912     GNUNET_GETOPT_OPTION_END
 913   };
 914   ok = 1;
 915   GNUNET_PROGRAM_run ((sizeof (argv1) / sizeof (char *)) - 1,
 916                       argv1, logger , "nohelp",
 917                       options, &run, &ok);
 918   ret = ok;
 919   stop_arm (&p1);
 920   stop_arm (&p2);
 921
 922   if (p1.servicehome != NULL)
 923     {
 924       GNUNET_DISK_directory_remove (p1.servicehome);
 925       GNUNET_free(p1.servicehome);
 926     }
 927   if (p2.servicehome != NULL)
 928     {
 929       GNUNET_DISK_directory_remove (p2.servicehome);
 930       GNUNET_free(p2.servicehome);
 931     }
 932   GNUNET_free(logger);
 933   return ret;
 934 }
 935
 936 /* end of test_quota_compliance.c */