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       if (n % 5000 == 0)
 308        {
 309           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 310                       "Sending message %u\n",n);
 311        }
 312 #endif
 313
 314     /*      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 315                       "Sending message %u\n",last_msg_sent);*/
 316
 317       s = get_size ();
 318       if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
 319         break; /* sometimes pack buffer full, sometimes not */
 320     }
 321   while (size - ret >= s);
 322   transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
 323                                             &p1.id,
 324                                             s, 0, SEND_TIMEOUT,
 325                                             &notify_ready,
 326                                             NULL);
 327   total_bytes_sent += s;
 328   return ret;
 329 }
 330
 331
 332 static void
 333 measure (unsigned long long quota_p1, unsigned long long quota_p2);
 334
 335 static void
 336 measurement_counter (void *cls,
 337                      const struct GNUNET_SCHEDULER_TaskContext *tc)
 338 {
 339   measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
 340   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 341     return;
 342
 343   fprintf(stderr,".");
 344   measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 345                                                            &measurement_counter,
 346                                                            NULL);
 347 }
 348
 349
 350 static void
 351 measurement_end (void *cls,
 352                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 353 {
 354   static int strike_counter;
 355   static int failed_measurement_counter = 1;
 356   unsigned long long  quota_allowed = 0;
 357   int delta = 0;
 358
 359   measurement_task  = GNUNET_SCHEDULER_NO_TASK;
 360   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 361     return;
 362
 363   measurement_running = GNUNET_NO;
 364   struct GNUNET_TIME_Relative duration
 365     = GNUNET_TIME_absolute_get_difference(start_time, GNUNET_TIME_absolute_get());
 366
 367
 368   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
 369     {
 370       GNUNET_SCHEDULER_cancel (measurement_counter_task);
 371       measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
 372     }
 373
 374   if (transmit_handle != NULL)
 375     {
 376       GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
 377       transmit_handle = NULL;
 378     }
 379
 380   if (current_quota_p1 < current_quota_p2)
 381     quota_allowed = current_quota_p1;
 382   else
 383     quota_allowed = current_quota_p2;
 384
 385
 386   if (MEASUREMENT_SOFT_LIMIT > (quota_allowed/3))
 387     delta = MEASUREMENT_SOFT_LIMIT;
 388   else
 389     delta = (quota_allowed/3);
 390
 391   /* Throughput is far too slow. This is to prevent the test to exit with success when throughput is 0 */
 392   if ((total_bytes_sent/(duration.rel_value / 1000)) < 100)
 393     {
 394       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 395                   "\nQuota compliance failed: \n"                       \
 396                   "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 397                   "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 398                   "Throughput              : %10llu kB/s (%llu B/s)\n",
 399                   (quota_allowed / (1024)), quota_allowed,
 400                   ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
 401                   (total_bytes_sent/(duration.rel_value / 1000)/1024),
 402                   total_bytes_sent/(duration.rel_value / 1000));
 403       ok = 1;
 404       failed_measurement_counter--;
 405       if (failed_measurement_counter < 0)
 406         {
 407           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 408                       "\nQuota measurement failed and no free strike: %i\n",
 409                       failed_measurement_counter);
 410           end();
 411           return;
 412         }
 413       else
 414         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 415                     "\nQuota measurement failed and %i free strikes\n",
 416                     failed_measurement_counter);
 417     }
 418
 419   /* Throughput is bigger than allowed quota + some extra*/
 420   if ((total_bytes_sent/(duration.rel_value / 1000)) > (quota_allowed + delta))
 421     {
 422       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 423                   "\nQuota compliance failed: \n"                       \
 424                   "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 425                   "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
 426                   "Throughput              : %10llu kB/s (%llu B/s)\n",
 427                   (quota_allowed / (1024)), quota_allowed,
 428                   ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
 429                   (total_bytes_sent/(duration.rel_value / 1000)/1024),
 430                   total_bytes_sent/(duration.rel_value / 1000));
 431       ok = 1;
 432       failed_measurement_counter--;
 433       if (failed_measurement_counter < 0)
 434         {
 435           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 436                       "\nQuota measurement failed and no free strike: %i\n",failed_measurement_counter);
 437           end();
 438           return;
 439         }
 440       else
 441         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 442                     "\nQuota measurement failed and %i free strikes\n",failed_measurement_counter);
 443     }
 444   else
 445     {
 446       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 447                   "\nQuota compliance ok: \n"                   \
 448                   "Quota allowed: %10llu kB/s\n"                        \
 449                   "Throughput   : %10llu kB/s\n",
 450                   (quota_allowed / (1024)),
 451                   (total_bytes_sent/(duration.rel_value / 1000)/1024));
 452       if (failed_measurement_counter < 2)
 453         failed_measurement_counter++;
 454       ok = 0;
 455     }
 456
 457   if ((quota_allowed) > (2 *(total_bytes_sent/(duration.rel_value / 1000))))
 458     {
 459       if (failed_measurement_counter < 2)
 460         failed_measurement_counter++;
 461       if (strike_counter == 2)
 462         {
 463           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 464                       "Maximum transmission rate reached, stopping test\n");
 465           end();
 466           return;
 467         }
 468     }
 469   else
 470     {
 471       strike_counter = 0;
 472     }
 473
 474   if (quota_allowed == MEASUREMENT_MAX_QUOTA)
 475     {
 476       end();
 477       return;
 478     }
 479   if (is_asymmetric_send_constant == GNUNET_YES)
 480     {
 481       if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
 482         measure (current_quota_p1 * 2, MEASUREMENT_MAX_QUOTA);
 483       else
 484         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
 485     }
 486   else if (is_asymmetric_recv_constant == GNUNET_YES)
 487     {
 488       if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
 489         measure (MEASUREMENT_MAX_QUOTA, current_quota_p2 * 2);
 490       else
 491         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
 492     }
 493   else
 494     {
 495       if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
 496         measure ((current_quota_p1) * 2, (current_quota_p2) * 2);
 497       else
 498         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
 499     }
 500 }
 501
 502 static void
 503 measure (unsigned long long quota_p1, unsigned long long quota_p2)
 504 {
 505   current_quota_p1 = quota_p1;
 506   current_quota_p2 = quota_p2;
 507 #if VERBOSE
 508   if ((is_asymmetric_send_constant == GNUNET_YES) || (is_asymmetric_recv_constant == GNUNET_YES))
 509     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 510                 "Starting transport level measurement for %u seconds, receiving peer quota %llu kB/s, sending peer quota %llu kB/s\n",
 511                 MEASUREMENT_INTERVALL.rel_value / 1000 ,
 512                 current_quota_p1 / 1024,
 513                 current_quota_p2 / 1024);
 514   else
 515     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 516                 "Starting transport level measurement for %u seconds, symmetric quota %llu kB/s\n",
 517                 MEASUREMENT_INTERVALL.rel_value / 1000,
 518                 current_quota_p2 / 1024);
 519
 520 #endif
 521   GNUNET_TRANSPORT_set_quota (p1.th,
 522                               &p2.id,
 523                               GNUNET_BANDWIDTH_value_init (current_quota_p1),
 524                               GNUNET_BANDWIDTH_value_init (current_quota_p1));
 525   GNUNET_TRANSPORT_set_quota (p2.th,
 526                               &p1.id,
 527                               GNUNET_BANDWIDTH_value_init (current_quota_p2),
 528                               GNUNET_BANDWIDTH_value_init (current_quota_p2));
 529   GNUNET_SCHEDULER_cancel (die_task);
 530   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 531                                            &end_badly,
 532                                            NULL);
 533   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
 534     GNUNET_SCHEDULER_cancel (measurement_counter_task);
 535   measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 536                                                            &measurement_counter,
 537                                                            NULL);
 538   measurement_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
 539                                                    &measurement_end,
 540                                                    NULL);
 541   total_bytes_sent = 0;
 542   last_msg_sent = 0;
 543   last_msg_recv = 0;
 544   measurement_running = GNUNET_YES;
 545   start_time = GNUNET_TIME_absolute_get ();
 546
 547   if (transmit_handle != NULL)
 548     GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
 549   transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
 550                                                             &p1.id,
 551                                                             get_size (), 0, SEND_TIMEOUT,
 552                                                             &notify_ready,
 553                                                             NULL);
 554 }
 555
 556
 557 static void
 558 exchange_hello_last (void *cls,
 559                      const struct GNUNET_MessageHeader *message)
 560 {
 561   struct PeerContext *me = cls;
 562
 563   GNUNET_assert (message != NULL);
 564   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 565               "Exchanging HELLO of size %d with peer (%s)!\n",
 566               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
 567               GNUNET_i2s (&me->id));
 568   GNUNET_assert (GNUNET_OK ==
 569                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
 570                                       message, &me->id));
 571   GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
 572 }
 573
 574
 575
 576 static void
 577 exchange_hello (void *cls,
 578                 const struct GNUNET_MessageHeader *message)
 579 {
 580   struct PeerContext *me = cls;
 581
 582   GNUNET_assert (message != NULL);
 583   GNUNET_assert (GNUNET_OK ==
 584                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
 585                                       message, &me->id));
 586   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 587               "Exchanging HELLO of size %d from peer %s!\n",
 588               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
 589               GNUNET_i2s (&me->id));
 590   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 591 }
 592
 593
 594 static void
 595 notify_connect (void *cls,
 596                 const struct GNUNET_PeerIdentity *peer,
 597                 const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
 598 {
 599   connected++;
 600  if (cls == &p1)
 601     {
 602 #if DEBUG_CONNECTIONS
 603       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 604                   "Peer 1 `%4s' connected to us (%p)!\n",
 605                   GNUNET_i2s (peer),
 606                   cls);
 607 #endif
 608     }
 609   else
 610     {
 611 #if DEBUG_CONNECTIONS
 612       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 613                   "Peer 2 `%4s' connected to us (%p)!\n",
 614                   GNUNET_i2s (peer),
 615                   cls);
 616 #endif
 617     }
 618   if (connected == 2)
 619     {
 620       GNUNET_SCHEDULER_cancel (tct);
 621       tct = GNUNET_SCHEDULER_NO_TASK;
 622       GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
 623       GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
 624       if (is_asymmetric_send_constant == GNUNET_YES)
 625         measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MAX_QUOTA);
 626       else if (is_asymmetric_recv_constant == GNUNET_YES)
 627         measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MIN_QUOTA);
 628       else
 629         measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MIN_QUOTA);
 630     }
 631 }
 632
 633
 634 static void
 635 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 636 {
 637   connected--;
 638 #if DEBUG_CONNECTIONS
 639   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 640               "Peer `%4s' disconnected (%p)!\n",
 641               GNUNET_i2s (peer), cls);
 642 #endif
 643 }
 644
 645
 646 static void
 647 setup_peer (struct PeerContext *p, const char *cfgname)
 648 {
 649   p->cfg = GNUNET_CONFIGURATION_create ();
 650   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 651   if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
 652     {
 653       GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome);
 654       GNUNET_DISK_directory_remove (p->servicehome);
 655     }
 656
 657 #if START_ARM
 658   p->arm_proc = GNUNET_OS_start_process (NULL, NULL,
 659                                         "gnunet-service-arm",
 660                                         "gnunet-service-arm",
 661 #if VERBOSE_ARM
 662                                         "-L", "DEBUG",
 663 #endif
 664                                         "-c", cfgname, NULL);
 665 #endif
 666
 667   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
 668                                     p,
 669                                     &notify_receive_new,
 670                                     &notify_connect,
 671                                     &notify_disconnect);
 672   GNUNET_assert (p->th != NULL);
 673 }
 674
 675
 676 static void
 677 try_connect (void *cls,
 678              const struct GNUNET_SCHEDULER_TaskContext *tc)
 679 {
 680   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 681               "Asking peers to connect...\n");
 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 #ifdef MINGW
 810       return 0;
 811 #endif
 812     }
 813   else if (strstr(argv[0], "tcp") != NULL)
 814     {
 815       is_tcp = GNUNET_YES;
 816     }
 817   else if (strstr(argv[0], "https") != NULL)
 818     {
 819       is_https = GNUNET_YES;
 820 #ifdef MINGW
 821       return 0;
 822 #endif
 823     }
 824   else if (strstr(argv[0], "http") != NULL)
 825     {
 826       is_http = GNUNET_YES;
 827     }
 828   else if (strstr(argv[0], "udp") != NULL)
 829     {
 830       is_udp = GNUNET_YES;
 831     }
 832   else if (strstr(argv[0], "unix") != NULL)
 833     {
 834       is_unix = GNUNET_YES;
 835     }
 836
 837   if (strstr(argv[0], "asymmetric_recv") != NULL)
 838   {
 839     is_asymmetric_recv_constant = GNUNET_YES;
 840   }
 841   else
 842     is_asymmetric_recv_constant = GNUNET_NO;
 843   if (strstr(argv[0], "asymmetric_send") != NULL)
 844     {
 845       is_asymmetric_send_constant = GNUNET_YES;
 846     }
 847   else
 848     is_asymmetric_send_constant = GNUNET_NO;
 849
 850   char * logger;
 851   if (is_tcp == GNUNET_YES)
 852     {
 853       if (is_asymmetric_recv_constant == GNUNET_YES)
 854         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_recv_constant");
 855       else if (is_asymmetric_send_constant == GNUNET_YES)
 856         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_send_constant");
 857       else
 858         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","symmetric");
 859     }
 860   else if (is_udp == GNUNET_YES)
 861     {
 862       if (is_asymmetric_recv_constant == GNUNET_YES)
 863         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_recv_constant");
 864       else if (is_asymmetric_send_constant == GNUNET_YES)
 865         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_send_constant");
 866       else
 867         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","symmetric");
 868     }
 869   else if (is_unix == GNUNET_YES)
 870     {
 871       if (is_asymmetric_recv_constant == GNUNET_YES)
 872         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_recv_constant");
 873       else if (is_asymmetric_send_constant == GNUNET_YES)
 874         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_send_constant");
 875       else
 876         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","symmetric");
 877     }
 878   else if (is_http == GNUNET_YES)
 879     {
 880       if (is_asymmetric_recv_constant == GNUNET_YES)
 881         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_recv_constant");
 882       else if (is_asymmetric_send_constant == GNUNET_YES)
 883         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_send_constant");
 884       else
 885         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","symmetric");
 886     }
 887   else if (is_https == GNUNET_YES)
 888     {
 889       if (is_asymmetric_recv_constant == GNUNET_YES)
 890         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_recv_constant");
 891       else if (is_asymmetric_send_constant == GNUNET_YES)
 892         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_send_constant");
 893       else
 894         GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","symmetric");
 895     }
 896   else
 897     {
 898       GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","noplugin","none");
 899     }
 900
 901   fprintf(stderr,  "Running `%s'\n", logger);
 902   GNUNET_log_setup ("test-quota-compliance",
 903 #if VERBOSE
 904                     "DEBUG",
 905 #else
 906                     "WARNING",
 907 #endif
 908                     NULL);
 909   char *const argv1[] = { "test-quota-compliance",
 910     "-c",
 911     "test_quota_compliance_data.conf",
 912 #if VERBOSE
 913     "-L", "DEBUG",
 914 #endif
 915     NULL
 916   };
 917   struct GNUNET_GETOPT_CommandLineOption options[] = {
 918     GNUNET_GETOPT_OPTION_END
 919   };
 920   ok = 1;
 921   GNUNET_PROGRAM_run ((sizeof (argv1) / sizeof (char *)) - 1,
 922                       argv1, logger , "nohelp",
 923                       options, &run, &ok);
 924   ret = ok;
 925   stop_arm (&p1);
 926   stop_arm (&p2);
 927
 928   if (p1.servicehome != NULL)
 929     {
 930       GNUNET_DISK_directory_remove (p1.servicehome);
 931       GNUNET_free(p1.servicehome);
 932     }
 933   if (p2.servicehome != NULL)
 934     {
 935       GNUNET_DISK_directory_remove (p2.servicehome);
 936       GNUNET_free(p2.servicehome);
 937     }
 938   GNUNET_free(logger);
 939   return ret;
 940 }
 941
 942 /* end of test_quota_compliance.c */