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   if (cls == &p2)
 636     {
 637       if (NULL != transmit_handle)
 638         {
 639           GNUNET_TRANSPORT_notify_transmit_ready_cancel (transmit_handle);
 640           transmit_handle = NULL;
 641         }
 642     }
 643   connected--;
 644 #if DEBUG_CONNECTIONS
 645   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 646               "Peer `%4s' disconnected (%p)!\n",
 647               GNUNET_i2s (peer), cls);
 648 #endif
 649 }
 650
 651
 652 static void
 653 setup_peer (struct PeerContext *p, const char *cfgname)
 654 {
 655   p->cfg = GNUNET_CONFIGURATION_create ();
 656   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 657   if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
 658     {
 659       GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
 660       GNUNET_DISK_directory_remove (p->servicehome);
 661     }
 662
 663 #if START_ARM
 664   p->arm_proc = GNUNET_OS_start_process (NULL, NULL,
 665                                         "gnunet-service-arm",
 666                                         "gnunet-service-arm",
 667 #if VERBOSE_ARM
 668                                         "-L", "DEBUG",
 669 #endif
 670                                         "-c", cfgname, NULL);
 671 #endif
 672
 673   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
 674                                     p,
 675                                     &notify_receive_new,
 676                                     &notify_connect,
 677                                     &notify_disconnect);
 678   GNUNET_assert (p->th != NULL);
 679 }
 680
 681
 682 static void
 683 try_connect (void *cls,
 684              const struct GNUNET_SCHEDULER_TaskContext *tc)
 685 {
 686 #if DEBUG_CONNECTIONS
 687   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 688               "Asking peers to connect...\n");
 689 #endif
 690   GNUNET_TRANSPORT_try_connect (p2.th,
 691                                 &p1.id);
 692   GNUNET_TRANSPORT_try_connect (p1.th,
 693                                 &p2.id);
 694   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 695                                       &try_connect,
 696                                       NULL);
 697 }
 698
 699
 700 static void
 701 run (void *cls,
 702      char *const *args,
 703      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 704 {
 705   GNUNET_assert (ok == 1);
 706   OKPP;
 707
 708   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 709                                            &end_badly,
 710                                            NULL);
 711   measurement_running = GNUNET_NO;
 712   send_running = GNUNET_NO;
 713   recv_running = GNUNET_NO;
 714
 715   if (is_tcp)
 716     {
 717       if (is_asymmetric_recv_constant == GNUNET_YES)
 718         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 719                     "Testing asymmetric quota compliance (receiver quota constant) for TCP transport plugin\n");
 720       else if (is_asymmetric_send_constant == GNUNET_YES)
 721         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 722                     "Testing asymmetric quota compliance (sender quota constant) for TCP transport plugin\n");
 723       else
 724         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 725                     "Testing symmetric quota compliance for TCP transport plugin\n");
 726       setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
 727       setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
 728     }
 729   else if (is_http)
 730     {
 731       if (is_asymmetric_recv_constant == GNUNET_YES)
 732         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 733                     "Testing asymmetric quota compliance (receiver quota constant) for HTTP transport plugin\n");
 734       else if (is_asymmetric_send_constant == GNUNET_YES)
 735         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 736                     "Testing asymmetric quota compliance (sender quota constant) for HTTP transport plugin\n");
 737       else
 738         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 739                     "Testing symmetric quota compliance for HTTP transport plugin\n");
 740       setup_peer (&p1, "test_quota_compliance_http_peer1.conf");
 741       setup_peer (&p2, "test_quota_compliance_http_peer2.conf");
 742     }
 743   else if (is_https)
 744     {
 745       if (is_asymmetric_recv_constant == GNUNET_YES)
 746         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 747                     "Testing asymmetric quota compliance (receiver quota constant) for HTTPS transport plugin\n");
 748       else if (is_asymmetric_send_constant == GNUNET_YES)
 749         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 750                     "Testing asymmetric quota compliance (sender quota constant) for HTTPS transport plugin\n");
 751       else
 752         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 753                     "Testing symmetric quota compliance for HTTPS transport plugin\n");
 754       setup_peer (&p1, "test_quota_compliance_https_peer1.conf");
 755       setup_peer (&p2, "test_quota_compliance_https_peer2.conf");
 756     }
 757   else if (is_udp)
 758     {
 759       if (is_asymmetric_recv_constant == GNUNET_YES)
 760         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 761                     "Testing asymmetric quota compliance (receiver quota constant) for UDP transport plugin\n");
 762       else if (is_asymmetric_send_constant == GNUNET_YES)
 763         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 764                     "Testing asymmetric quota compliance (sender quota constant) for UDP transport plugin\n");
 765       else
 766         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 767                     "Testing symmetric quota compliance for UDP transport plugin\n");
 768       setup_peer (&p1, "test_quota_compliance_udp_peer1.conf");
 769       setup_peer (&p2, "test_quota_compliance_udp_peer2.conf");
 770     }
 771   else if (is_unix)
 772     {
 773       if (is_asymmetric_recv_constant == GNUNET_YES)
 774         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 775                     "Testing asymmetric quota compliance (receiver quota constant) for UNIX transport plugin\n");
 776       else if (is_asymmetric_send_constant == GNUNET_YES)
 777         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 778                     "Testing asymmetric quota compliance (sender quota constant) for UNIX transport plugin\n");
 779       else
 780         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 781                     "Testing symmetric quota compliance for UNIX transport plugin\n");
 782       setup_peer (&p1, "test_quota_compliance_unix_peer1.conf");
 783       setup_peer (&p2, "test_quota_compliance_unix_peer2.conf");
 784     }
 785   else if (is_tcp_nat)
 786     {
 787       if (is_asymmetric_recv_constant == GNUNET_YES)
 788         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 789                     "Testing asymmetric quota compliance (receiver quota constant) for TCP NAT transport plugin\n");
 790       else if (is_asymmetric_send_constant == GNUNET_YES)
 791         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 792                     "Testing asymmetric quota compliance (sender quota constant) for TCP NAT transport plugin\n");
 793       else
 794         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 795                     "Testing symmetric quota compliance for TCP NAT transport plugin\n");
 796       setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
 797       setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
 798     }
 799   else
 800     GNUNET_assert (0);
 801
 802   GNUNET_assert(p1.th != NULL);
 803   GNUNET_assert(p2.th != NULL);
 804   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
 805   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
 806   tct = GNUNET_SCHEDULER_add_now (&try_connect, NULL);
 807 }
 808
 809
 810 int
 811 main (int argc, char *argv[])
 812 {
 813   int ret = 0;
 814   if (strstr(argv[0], "tcp_nat") != NULL)
 815     {
 816       is_tcp_nat = GNUNET_YES;
 817     }
 818   else if (strstr(argv[0], "tcp") != NULL)
 819     {
 820       is_tcp = GNUNET_YES;
 821     }
 822   else if (strstr(argv[0], "https") != NULL)
 823     {
 824       is_https = GNUNET_YES;
 825     }
 826   else if (strstr(argv[0], "http") != NULL)
 827     {
 828       is_http = GNUNET_YES;
 829     }
 830   else if (strstr(argv[0], "udp") != NULL)
 831     {
 832       is_udp = GNUNET_YES;
 833     }
 834   else if (strstr(argv[0], "unix") != NULL)
 835     {
 836       is_unix = GNUNET_YES;
 837     }
 838
 839   if (strstr(argv[0], "asymmetric_recv") != NULL)
 840   {
 841     is_asymmetric_recv_constant = GNUNET_YES;
 842   }
 843   else
 844     is_asymmetric_recv_constant = GNUNET_NO;
 845   if (strstr(argv[0], "asymmetric_send") != NULL)
 846     {
 847       is_asymmetric_send_constant = GNUNET_YES;
 848     }
 849   else
 850     is_asymmetric_send_constant = GNUNET_NO;
 851
 852   char * logger;
 853   if (is_tcp == GNUNET_YES)
 854     {
 855       if (is_asymmetric_recv_constant == GNUNET_YES)
 856         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_recv_constant");
 857       else if (is_asymmetric_send_constant == GNUNET_YES)
 858         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_send_constant");
 859       else
 860         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","symmetric");
 861     }
 862   else if (is_udp == GNUNET_YES)
 863     {
 864       if (is_asymmetric_recv_constant == GNUNET_YES)
 865         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_recv_constant");
 866       else if (is_asymmetric_send_constant == GNUNET_YES)
 867         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_send_constant");
 868       else
 869         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","symmetric");
 870     }
 871   else if (is_unix == GNUNET_YES)
 872     {
 873       if (is_asymmetric_recv_constant == GNUNET_YES)
 874         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_recv_constant");
 875       else if (is_asymmetric_send_constant == GNUNET_YES)
 876         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_send_constant");
 877       else
 878         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","symmetric");
 879     }
 880   else if (is_http == GNUNET_YES)
 881     {
 882       if (is_asymmetric_recv_constant == GNUNET_YES)
 883         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_recv_constant");
 884       else if (is_asymmetric_send_constant == GNUNET_YES)
 885         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_send_constant");
 886       else
 887         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","symmetric");
 888     }
 889   else if (is_https == GNUNET_YES)
 890     {
 891       if (is_asymmetric_recv_constant == GNUNET_YES)
 892         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_recv_constant");
 893       else if (is_asymmetric_send_constant == GNUNET_YES)
 894         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_send_constant");
 895       else
 896         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","symmetric");
 897     }
 898   else
 899     {
 900       GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","noplugin","none");
 901     }
 902
 903   fprintf(stderr,  "Running `%s'\n", logger);
 904   GNUNET_log_setup ("test-quota-compliance",
 905 #if VERBOSE
 906                     "DEBUG",
 907 #else
 908                     "WARNING",
 909 #endif
 910                     NULL);
 911   char *const argv1[] = { "test-quota-compliance",
 912     "-c",
 913     "test_quota_compliance_data.conf",
 914 #if VERBOSE
 915     "-L", "DEBUG",
 916 #endif
 917     NULL
 918   };
 919   struct GNUNET_GETOPT_CommandLineOption options[] = {
 920     GNUNET_GETOPT_OPTION_END
 921   };
 922   ok = 1;
 923   GNUNET_PROGRAM_run ((sizeof (argv1) / sizeof (char *)) - 1,
 924                       argv1, logger , "nohelp",
 925                       options, &run, &ok);
 926   ret = ok;
 927   stop_arm (&p1);
 928   stop_arm (&p2);
 929
 930   if (p1.servicehome != NULL)
 931     {
 932       GNUNET_DISK_directory_remove (p1.servicehome);
 933       GNUNET_free(p1.servicehome);
 934     }
 935   if (p2.servicehome != NULL)
 936     {
 937       GNUNET_DISK_directory_remove (p2.servicehome);
 938       GNUNET_free(p2.servicehome);
 939     }
 940   GNUNET_free(logger);
 941   return ret;
 942 }
 943
 944 /* end of test_quota_compliance.c */