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 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 "gauger.h"
  36 #include "transport.h"
  37 #include "transport-testing.h"
  38
  39 #define VERBOSE GNUNET_NO
  40
  41 #define VERBOSE_ARM GNUNET_EXTRA_LOGGING
  42
  43 #define START_ARM GNUNET_YES
  44
  45 /**
  46  * Testcase timeout
  47  */
  48 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  49
  50 /**
  51  * How long until we give up on transmitting the message?
  52  */
  53 #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
  54
  55 #define DURATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  56
  57 static char *test_source;
  58
  59 static char *test_plugin;
  60
  61 static char *test_name;
  62
  63 static int ok;
  64
  65 static GNUNET_SCHEDULER_TaskIdentifier die_task;
  66
  67 static GNUNET_SCHEDULER_TaskIdentifier measure_task;
  68
  69 struct PeerContext *p1;
  70
  71 struct PeerContext *p2;
  72
  73 struct PeerContext * sender;
  74
  75 struct PeerContext * receiver;
  76
  77 struct GNUNET_TRANSPORT_TransmitHandle *th;
  78
  79 char *cfg_file_p1;
  80 char *gen_cfg_p2;
  81 unsigned long long quota_in_p1;
  82 unsigned long long quota_out_p1;
  83
  84 char *cfg_file_p2;
  85 char *gen_cfg_p1;
  86 unsigned long long quota_in_p2;
  87 unsigned long long quota_out_p2;
  88
  89 struct GNUNET_TRANSPORT_TESTING_handle * tth;
  90
  91 static GNUNET_TRANSPORT_TESTING_ConnectRequest cc;
  92
  93
  94 /*
  95  * Testcase specific declarations
  96  */
  97
  98 /**
  99  * Note that this value must not significantly exceed
 100  * 'MAX_PENDING' in 'gnunet-service-transport.c', otherwise
 101  * messages may be dropped even for a reliable transport.
 102  */
 103 #define TOTAL_MSGS (1024 * 2)
 104
 105 #define MTYPE 12345
 106
 107 struct TestMessage
 108 {
 109   struct GNUNET_MessageHeader header;
 110   uint32_t num;
 111 };
 112
 113 static int msg_scheduled;
 114 static int msg_sent;
 115 static int msg_recv_expected;
 116 static int msg_recv;
 117
 118 static int test_failed;
 119 static int test_connected;
 120
 121 static unsigned long long total_bytes_sent;
 122
 123 static struct GNUNET_TIME_Absolute start_time;
 124
 125 /*
 126  * END Testcase specific declarations
 127  */
 128
 129 #if VERBOSE
 130 #define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
 131 #else
 132 #define OKPP do { ok++; } while (0)
 133 #endif
 134
 135
 136 static void
 137 end ()
 138 {
 139   unsigned long long delta;
 140   unsigned long long datarate;
 141
 142   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
 143
 144   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
 145   datarate = (total_bytes_sent * 1000) / delta;
 146
 147   fprintf (stderr, "\nThroughput was %llu b/s\n",
 148            datarate);
 149
 150   test_failed = GNUNET_NO;
 151   if (datarate > quota_in_p2)
 152   {
 153     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 154         "Datarate of %llu b/s higher than allowed inbound quota of %llu b/s\n", datarate, quota_in_p2);
 155     test_failed = GNUNET_YES;
 156   }
 157   if (datarate > quota_out_p1)
 158   {
 159     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 160         "Datarate of %llu b/s higher than allowed outbound quota of %llu b/s\n", datarate, quota_out_p1);
 161     test_failed = GNUNET_YES;
 162   }
 163   if (test_failed == GNUNET_NO)
 164   {
 165     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 166         "Datarate of %llu b/s complied to allowed outbound quota of %llu b/s and inbound quota of %llu b/s\n", datarate, quota_out_p1, quota_in_p2);
 167   }
 168
 169   if (die_task != GNUNET_SCHEDULER_NO_TASK)
 170     GNUNET_SCHEDULER_cancel (die_task);
 171
 172   if (th != NULL)
 173     GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
 174   th = NULL;
 175
 176   if (cc != NULL)
 177     GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
 178
 179   GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
 180   GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
 181
 182 }
 183
 184 static void
 185 end_badly ()
 186 {
 187   die_task = GNUNET_SCHEDULER_NO_TASK;
 188   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 189
 190   if (measure_task != GNUNET_SCHEDULER_NO_TASK)
 191     GNUNET_SCHEDULER_cancel (measure_task);
 192
 193   if (test_connected == GNUNET_YES)
 194     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers got connected\n");
 195   else
 196     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers got NOT connected\n");
 197
 198   if (th != NULL)
 199     GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
 200   th = NULL;
 201
 202   if (cc != NULL)
 203     GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
 204
 205   if (p1 != NULL)
 206     GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
 207   if (p2 != NULL)
 208     GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
 209
 210   ok = GNUNET_SYSERR;
 211 }
 212
 213
 214 static unsigned int
 215 get_size (unsigned int iter)
 216 {
 217   unsigned int ret;
 218
 219   ret = (iter * iter * iter);
 220   return sizeof (struct TestMessage) + (ret % 60000);
 221 }
 222
 223
 224 static void
 225 notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
 226                 const struct GNUNET_MessageHeader *message,
 227                 const struct GNUNET_ATS_Information *ats,
 228                 uint32_t ats_count)
 229 {
 230   static int n;
 231   unsigned int s;
 232   char cbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
 233   const struct TestMessage *hdr;
 234
 235   hdr = (const struct TestMessage *) message;
 236   s = get_size (n);
 237   if (MTYPE != ntohs (message->type))
 238     return;
 239   msg_recv_expected = n;
 240   msg_recv = ntohl (hdr->num);
 241   if (ntohs (message->size) != (s))
 242   {
 243     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 244                 "Expected message %u of size %u, got %u bytes of message %u\n",
 245                 n, s, ntohs (message->size), ntohl (hdr->num));
 246     if (die_task != GNUNET_SCHEDULER_NO_TASK)
 247       GNUNET_SCHEDULER_cancel (die_task);
 248     test_failed = GNUNET_YES;
 249     die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 250     return;
 251   }
 252   if (ntohl (hdr->num) != n)
 253   {
 254     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 255                 "Expected message %u of size %u, got %u bytes of message %u\n",
 256                 n, s, ntohs (message->size), ntohl (hdr->num));
 257     if (die_task != GNUNET_SCHEDULER_NO_TASK)
 258       GNUNET_SCHEDULER_cancel (die_task);
 259     test_failed = GNUNET_YES;
 260     die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 261     return;
 262   }
 263   memset (cbuf, n, s - sizeof (struct TestMessage));
 264   if (0 != memcmp (cbuf, &hdr[1], s - sizeof (struct TestMessage)))
 265   {
 266     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 267                 "Expected message %u with bits %u, but body did not match\n", n,
 268                 (unsigned char) n);
 269     if (die_task != GNUNET_SCHEDULER_NO_TASK)
 270       GNUNET_SCHEDULER_cancel (die_task);
 271     test_failed = GNUNET_YES;
 272     die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 273     return;
 274   }
 275 #if VERBOSE
 276   if (ntohl (hdr->num) % 5000 == 0)
 277   {
 278     struct PeerContext *p = cls;
 279     char * ps = strdup(GNUNET_i2s(&p->id));
 280     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%s') got message %u of size %u from peer (`%s')\n",
 281                 p->no, ps, ntohl (hdr->num), ntohs (message->size), GNUNET_i2s(peer));
 282     GNUNET_free (ps);
 283   }
 284 #endif
 285   n++;
 286 }
 287
 288
 289 static size_t
 290 notify_ready (void *cls, size_t size, void *buf)
 291 {
 292   static int n;
 293   char *cbuf = buf;
 294   struct TestMessage hdr;
 295   unsigned int s;
 296   unsigned int ret;
 297
 298   th = NULL;
 299   if (buf == NULL)
 300   {
 301     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 302                 "Timeout occurred while waiting for transmit_ready for message %u of %u\n", msg_scheduled, TOTAL_MSGS);
 303     if (GNUNET_SCHEDULER_NO_TASK != die_task)
 304       GNUNET_SCHEDULER_cancel (die_task);
 305     die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 306     ok = 42;
 307     return 0;
 308   }
 309
 310   ret = 0;
 311   s = get_size (n);
 312   GNUNET_assert (size >= s);
 313   GNUNET_assert (buf != NULL);
 314   cbuf = buf;
 315   do
 316   {
 317     hdr.header.size = htons (s);
 318     hdr.header.type = htons (MTYPE);
 319     hdr.num = htonl (n);
 320     msg_sent = n;
 321     memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
 322     ret += sizeof (struct TestMessage);
 323     memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
 324     ret += s - sizeof (struct TestMessage);
 325 #if VERBOSE
 326     if (n % 5000 == 0)
 327     {
 328
 329       char * receiver_s = strdup(GNUNET_i2s (&receiver->id));
 330       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 331                   "Sending message of size %u from peer %u (`%4s') -> peer %u (`%s') !\n",
 332                   n,
 333                   sender->no,
 334                   GNUNET_i2s (&sender->id), receiver->no, receiver_s);
 335       GNUNET_free (receiver_s);
 336     }
 337 #endif
 338     n++;
 339     s = get_size (n);
 340     if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
 341       break;                    /* sometimes pack buffer full, sometimes not */
 342   }
 343   while (size - ret >= s);
 344   if (n < TOTAL_MSGS)
 345   {
 346     if (th == NULL)
 347       th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, s, 0,
 348                                                    TIMEOUT_TRANSMIT,
 349                                                    &notify_ready, NULL);
 350     msg_scheduled = n;
 351   }
 352   if (n % 5000 == 0)
 353   {
 354     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 355                 "Returning total message block of size %u\n", ret);
 356   }
 357   total_bytes_sent += ret;
 358   if (n == TOTAL_MSGS)
 359   {
 360     fprintf (stderr, "\n");
 361     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All messages sent\n");
 362   }
 363   return ret;
 364 }
 365
 366
 367 static void
 368 notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
 369                 const struct GNUNET_ATS_Information *ats,
 370                 uint32_t ats_count)
 371 {
 372
 373   struct PeerContext *p = cls;
 374   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%4s') connected to us!\n",
 375               p->no, GNUNET_i2s (peer));
 376 }
 377
 378
 379 static void
 380 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 381 {
 382   struct PeerContext *p = cls;
 383   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%4s') disconnected!\n",
 384               p->no, GNUNET_i2s (peer));
 385   if (th != NULL)
 386     GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
 387   th = NULL;
 388
 389 }
 390
 391 static void
 392 sendtask ()
 393 {
 394   start_time = GNUNET_TIME_absolute_get ();
 395   th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, get_size (0), 0,
 396                                                TIMEOUT_TRANSMIT, &notify_ready,
 397                                                NULL);
 398 }
 399
 400
 401 static void
 402 measure (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 403 {
 404   static int counter;
 405   measure_task = GNUNET_SCHEDULER_NO_TASK;
 406
 407   counter++;
 408   if ((DURATION.rel_value / 1000) < counter )
 409   {
 410     fprintf (stderr, ".\n");
 411     GNUNET_SCHEDULER_add_now (&end, NULL);
 412   }
 413   else
 414   {
 415     fprintf (stderr, ".");
 416     measure_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &measure, NULL);
 417   }
 418 }
 419
 420
 421 static void
 422 testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 423 {
 424   char *p1_c = strdup (GNUNET_i2s (&p1->id));
 425   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %u (%s) <-> %u (%s)\n",
 426               p1->no, p1_c,
 427               p2->no, GNUNET_i2s (&p2->id));
 428   GNUNET_free (p1_c);
 429
 430   cc = NULL;
 431   test_connected = GNUNET_YES;
 432
 433   measure_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &measure, NULL);
 434   GNUNET_SCHEDULER_add_now (&sendtask, NULL);
 435
 436 }
 437
 438 void start_cb (struct PeerContext * p,
 439                void *cls)
 440 {
 441   static int started;
 442   started++;
 443
 444   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%s') started\n",
 445        p->no,
 446        GNUNET_i2s (&p->id));
 447
 448   if (started != 2)
 449     return;
 450
 451   test_connected = GNUNET_NO;
 452
 453   sender = p2;
 454   receiver = p1;
 455
 456   char *sender_c = strdup (GNUNET_i2s (&sender->id));
 457   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test tries to send from %u (%s) -> peer %u (%s)\n",
 458               sender->no, sender_c,
 459               receiver->no, GNUNET_i2s (&receiver->id));
 460
 461   cc = GNUNET_TRANSPORT_TESTING_connect_peers (tth, p1, p2, &testing_connect_cb, NULL);
 462
 463 }
 464
 465 static char *
 466 generate_config (char * cfg_file,  unsigned long long  quota_in,  unsigned long long  quota_out)
 467 {
 468   char * fname = NULL;
 469   struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create();
 470   GNUNET_CONFIGURATION_load (cfg, cfg_file);
 471   GNUNET_asprintf (&fname, "q_in_%u_q_out_%u_%s", quota_in, quota_out, cfg_file);
 472   GNUNET_CONFIGURATION_set_value_string(cfg, "PATHS", "DEFAULTCONFIG", fname);
 473   GNUNET_CONFIGURATION_set_value_number(cfg, "core", "TOTAL_QUOTA_OUT", quota_out);
 474   GNUNET_CONFIGURATION_set_value_number(cfg, "core", "TOTAL_QUOTA_IN", quota_in);
 475   GNUNET_CONFIGURATION_set_value_number(cfg, "ats", "TOTAL_QUOTA_IN", quota_in);
 476   GNUNET_CONFIGURATION_set_value_number(cfg, "ats", "TOTAL_QUOTA_OUT", quota_out);
 477   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write(cfg, fname));
 478   GNUNET_CONFIGURATION_destroy(cfg);
 479   return fname;
 480 }
 481
 482 static void
 483 run_measurement (unsigned long long p1_quota_in, unsigned long long p1_quota_out,
 484                  unsigned long long p2_quota_in, unsigned long long p2_quota_out)
 485 {
 486   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 487
 488   /* setting ATS quota */
 489   quota_out_p1 = p1_quota_out;
 490   gen_cfg_p1 = generate_config(cfg_file_p1, p1_quota_in, p1_quota_out);
 491   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 492       "Generated config file `%s'\n",
 493       gen_cfg_p1);
 494
 495   quota_in_p2 = p2_quota_in;
 496   gen_cfg_p2 = generate_config(cfg_file_p2, p2_quota_in, p2_quota_out);
 497   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 498       "Generated config file `%s'\n",
 499       gen_cfg_p2);
 500
 501   p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, cfg_file_p1, 1,
 502                                             &notify_receive,
 503                                             &notify_connect, &notify_disconnect,
 504                                             &start_cb,
 505                                             NULL);
 506
 507   p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, cfg_file_p2, 2,
 508                                             &notify_receive,
 509                                             &notify_connect, &notify_disconnect,
 510                                             &start_cb,
 511                                             NULL);
 512
 513   if ((p1 == NULL) || (p2 == NULL))
 514   {
 515     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Fail! Could not start peers!\n");
 516     if (die_task != GNUNET_SCHEDULER_NO_TASK)
 517       GNUNET_SCHEDULER_cancel (die_task);
 518     die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 519     return;
 520   }
 521 }
 522
 523 static void
 524 run (void *cls, char *const *args, const char *cfgfile,
 525      const struct GNUNET_CONFIGURATION_Handle *cfg)
 526 {
 527   unsigned long long p1_quota_in = 10000;
 528   unsigned long long p1_quota_out = 10000;
 529   unsigned long long p2_quota_in = 10000;
 530   unsigned long long p2_quota_out = 10000;
 531
 532   if (NULL != strstr (test_name,"asymmetric"))
 533   {
 534     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 535         "Running asymmetric test with sending peer unlimited, receiving peer (in/out): %llu/%llu b/s \n",
 536         p2_quota_in, p2_quota_out);
 537     p1_quota_out = 1024 * 1024 * 1024;
 538     p1_quota_in = 1024 * 1024 * 1024;
 539   }
 540   else
 541   {
 542     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 543         "Running symmetric test with (in/out) %llu/%llu b/s \n",
 544         p2_quota_in, p2_quota_out);
 545   }
 546   run_measurement (p1_quota_in, p1_quota_out, p2_quota_in, p2_quota_out);
 547 }
 548
 549 static int
 550 check ()
 551 {
 552   static char *argv[] = { "test_transport-quota-compliance",
 553     "-c",
 554     "",
 555 #if VERBOSE
 556     "-L", "DEBUG",
 557 #endif
 558     NULL
 559   };
 560   static struct GNUNET_GETOPT_CommandLineOption options[] = {
 561     GNUNET_GETOPT_OPTION_END
 562   };
 563
 564   ok = 1;
 565   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv, test_name,
 566                       "nohelp", options, &run, &ok);
 567
 568   return ok;
 569 }
 570
 571 int
 572 main (int argc, char *argv[])
 573 {
 574   int ret;
 575   int nat_res;
 576
 577   tth = GNUNET_TRANSPORT_TESTING_init ();
 578
 579   GNUNET_TRANSPORT_TESTING_get_test_source_name (__FILE__, &test_source);
 580   GNUNET_TRANSPORT_TESTING_get_test_plugin_name (argv[0], test_source,
 581                                                  &test_plugin);
 582   GNUNET_TRANSPORT_TESTING_get_test_name (argv[0], &test_name);
 583
 584   GNUNET_log_setup (test_name,
 585 #if VERBOSE
 586                     "DEBUG",
 587 #else
 588                     "WARNING",
 589 #endif
 590                     NULL);
 591
 592   if ((strcmp (test_plugin, "tcp_nat") == 0) ||
 593       (strcmp (test_plugin, "udp_nat") == 0))
 594   {
 595     nat_res = GNUNET_OS_check_helper_binary ("gnunet-nat-server");
 596     if (GNUNET_NO == nat_res)
 597     {
 598       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Cannot run NAT test: `%s' %s \n",
 599                   "gnunet-nat-server", "SUID not set");
 600       return 0;
 601     }
 602     if (GNUNET_SYSERR == nat_res)
 603     {
 604       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Cannot run NAT test: `%s' %s \n",
 605                   "gnunet-nat-server", "file not found");
 606       return 0;
 607     }
 608   }
 609
 610   GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], &cfg_file_p1, 1);
 611   GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], &cfg_file_p2, 2);
 612
 613   ret = check ();
 614
 615   GNUNET_free (cfg_file_p1);
 616   GNUNET_free (cfg_file_p2);
 617
 618   if (GNUNET_YES == GNUNET_DISK_file_test (gen_cfg_p1))
 619   {
 620     GNUNET_DISK_directory_remove (gen_cfg_p1);
 621     GNUNET_free (gen_cfg_p1);
 622   }
 623
 624   if (GNUNET_YES == GNUNET_DISK_file_test (gen_cfg_p2))
 625   {
 626     GNUNET_DISK_directory_remove (gen_cfg_p2);
 627     GNUNET_free (gen_cfg_p2);
 628   }
 629
 630   GNUNET_free (test_source);
 631   GNUNET_free (test_plugin);
 632   GNUNET_free (test_name);
 633
 634   GNUNET_TRANSPORT_TESTING_done (tth);
 635
 636   return test_failed;
 637 }
 638
 639
 640 /* end of test_quota_compliance.c */