adapting testcases to use new API

1 files changed, 381 insertions, 335 deletions

diff --git a/src/transport/test_quota_compliance.c b/src/transport/test_quota_compliance.c
index 1f4d21fc8..48a78f19d 100644
--- a/src/transport/test_quota_compliance.c
+++ b/src/transport/test_quota_compliance.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2010 Christian Grothoff (and other contributing authors)
+     (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -146,6 +146,7 @@ static int is_asymmetric_recv_constant;
 static struct GNUNET_TIME_Absolute start_time;
 
 static GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier tct;
 static GNUNET_SCHEDULER_TaskIdentifier measurement_task;
 static GNUNET_SCHEDULER_TaskIdentifier measurement_counter_task;
 
@@ -154,33 +155,27 @@ static struct GNUNET_TRANSPORT_TransmitHandle * transmit_handle;
 #define OKPP do { ok++; } while (0)
 
 
-
-static void
-end_send ()
-{
-
-}
-
 static void
 end ()
 {
   GNUNET_SCHEDULER_cancel (die_task);
   die_task = GNUNET_SCHEDULER_NO_TASK;
-
+  
   if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
-  {
-            GNUNET_SCHEDULER_cancel (measurement_task);
-            measurement_task = GNUNET_SCHEDULER_NO_TASK;
-  }
+    {
+      GNUNET_SCHEDULER_cancel (measurement_task);
+      measurement_task = GNUNET_SCHEDULER_NO_TASK;
+    }
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-  {
-            GNUNET_SCHEDULER_cancel (measurement_counter_task);
-            measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-  }
+    {
+      GNUNET_SCHEDULER_cancel (measurement_counter_task);
+      measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
+    }
   fprintf(stderr,"\n");
   GNUNET_SCHEDULER_shutdown ();
 #if DEBUG_CONNECTIONS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting from transports!\n");
 #endif
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
@@ -213,19 +208,24 @@ end_badly (void *cls,
 {
   if (measurement_task != GNUNET_SCHEDULER_NO_TASK)
   {
-            GNUNET_SCHEDULER_cancel (measurement_task);
-            measurement_task = GNUNET_SCHEDULER_NO_TASK;
+    GNUNET_SCHEDULER_cancel (measurement_task);
+    measurement_task = GNUNET_SCHEDULER_NO_TASK;
   }
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-  {
-            GNUNET_SCHEDULER_cancel (measurement_counter_task);
-            measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-  }
+    {
+      GNUNET_SCHEDULER_cancel (measurement_counter_task);
+      measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
+    }
   GNUNET_break (0);
+  if (GNUNET_SCHEDULER_NO_TASK != tct)
+    {
+      GNUNET_SCHEDULER_cancel (tct);
+      tct = GNUNET_SCHEDULER_NO_TASK;
+    }
   if (p1.th != NULL)
-          GNUNET_TRANSPORT_disconnect (p1.th);
+    GNUNET_TRANSPORT_disconnect (p1.th);
   if (p2.th != NULL)
-          GNUNET_TRANSPORT_disconnect (p2.th);
+    GNUNET_TRANSPORT_disconnect (p2.th);
   ok = 1;
 }
 
@@ -235,6 +235,7 @@ struct TestMessage
   uint32_t num;
 };
 
+
 static unsigned int
 get_size ()
 {
@@ -271,6 +272,7 @@ notify_receive_new (void *cls,
   last_msg_recv = ntohl (hdr->num);
 }
 
+
 static size_t
 notify_ready (void *cls, size_t size, void *buf)
 {
@@ -280,23 +282,19 @@ notify_ready (void *cls, size_t size, void *buf)
   unsigned int ret;
 
   transmit_handle = NULL;
-
   if (measurement_task == GNUNET_SCHEDULER_NO_TASK)
-          return 0;
+    return 0;
 
   if (buf == NULL)
     {
       ok = 42;
       return 0;
     }
-
   if (measurement_running != GNUNET_YES)
-  {
-          send_running = GNUNET_NO;
-          end_send();
-          return 0;
-  }
-
+    {
+      send_running = GNUNET_NO;
+      return 0;
+    }
   send_running = GNUNET_YES;
   ret = 0;
   s = get_size ();
@@ -338,26 +336,28 @@ notify_ready (void *cls, size_t size, void *buf)
   return ret;
 }
 
-static void measure (unsigned long long quota_p1, unsigned long long quota_p2 );
 
-static void measurement_counter
- (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+measure (unsigned long long quota_p1, unsigned long long quota_p2);
+
+static void 
+measurement_counter (void *cls,
+                     const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-        return;
-
+    return;
+  
   fprintf(stderr,".");
   measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                            &measurement_counter,
                                                            NULL);
 }
 
+
 static void
 measurement_end (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+                 const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   static int strike_counter;
   static int failed_measurement_counter = 1;
@@ -366,219 +366,275 @@ measurement_end (void *cls,
 
   measurement_task  = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-        return;
+    return;
 
   measurement_running = GNUNET_NO;
-  struct GNUNET_TIME_Relative duration = GNUNET_TIME_absolute_get_difference(start_time, GNUNET_TIME_absolute_get());
+  struct GNUNET_TIME_Relative duration
+    = GNUNET_TIME_absolute_get_difference(start_time, GNUNET_TIME_absolute_get());
 
 
   if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-  {
-    GNUNET_SCHEDULER_cancel (measurement_counter_task);
-    measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
-  }
-
+    {
+      GNUNET_SCHEDULER_cancel (measurement_counter_task);
+      measurement_counter_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+  
   if (transmit_handle != NULL)
-  {
-          GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
-          transmit_handle = NULL;
-  }
-
+    {
+      GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
+      transmit_handle = NULL;
+    }
+  
   if (current_quota_p1 < current_quota_p2)
-          quota_allowed = current_quota_p1;
+    quota_allowed = current_quota_p1;
   else
-          quota_allowed = current_quota_p2;
-
-
+    quota_allowed = current_quota_p2;
+  
+  
   if (MEASUREMENT_SOFT_LIMIT > (quota_allowed/3))
-          delta = MEASUREMENT_SOFT_LIMIT;
+    delta = MEASUREMENT_SOFT_LIMIT;
   else
-          delta = (quota_allowed/3);
-
+    delta = (quota_allowed/3);
+  
   /* Throughput is far too slow. This is to prevent the test to exit with success when throughput is 0 */
   if ((total_bytes_sent/(duration.rel_value / 1000)) < 100)
-  {
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "\nQuota compliance failed: \n"                       \
+                  "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
+                  "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
+                  "Throughput              : %10llu kB/s (%llu B/s)\n",
+                  (quota_allowed / (1024)), quota_allowed,
+                  ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
+                  (total_bytes_sent/(duration.rel_value / 1000)/1024),
+                  total_bytes_sent/(duration.rel_value / 1000));
+      ok = 1;
+      failed_measurement_counter--;
+      if (failed_measurement_counter < 0)
+        {
           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                          "\nQuota compliance failed: \n"\
-                          "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"\
-                          "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"\
-                          "Throughput              : %10llu kB/s (%llu B/s)\n",
-                          (quota_allowed / (1024)), quota_allowed,
-                          ((quota_allowed+delta) / (1024)),  quota_allowed+delta,
-                          (total_bytes_sent/(duration.rel_value / 1000)/1024),
-                          total_bytes_sent/(duration.rel_value / 1000));
-          ok = 1;
-          failed_measurement_counter--;
-          if (failed_measurement_counter < 0)
-          {
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  "\nQuota measurement failed and no free strike: %i\n",failed_measurement_counter);
-                  end();
-                  return;
-          }
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  "\nQuota measurement failed and %i free strikes\n",failed_measurement_counter);
-  }
-
+                      "\nQuota measurement failed and no free strike: %i\n",
+                      failed_measurement_counter);
+          end();
+          return;
+        }
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "\nQuota measurement failed and %i free strikes\n",
+                    failed_measurement_counter);
+    }
+  
   /* Throughput is bigger than allowed quota + some extra*/
   if ((total_bytes_sent/(duration.rel_value / 1000)) > (quota_allowed + delta))
-  {
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "\nQuota compliance failed: \n"                       \
+                  "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
+                  "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"  \
+                  "Throughput              : %10llu kB/s (%llu B/s)\n", 
+                  (quota_allowed / (1024)), quota_allowed, 
+                  ((quota_allowed+delta) / (1024)),  quota_allowed+delta, 
+                  (total_bytes_sent/(duration.rel_value / 1000)/1024), 
+                  total_bytes_sent/(duration.rel_value / 1000));
+      ok = 1;
+      failed_measurement_counter--;
+      if (failed_measurement_counter < 0)
+        {
           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                          "\nQuota compliance failed: \n"\
-                          "Hard quota limit allowed: %10llu kB/s (%llu B/s)\n"\
-                          "Soft quota limit allowed: %10llu kB/s (%llu B/s)\n"\
-                          "Throughput              : %10llu kB/s (%llu B/s)\n", 
-                          (quota_allowed / (1024)), quota_allowed, 
-                          ((quota_allowed+delta) / (1024)),  quota_allowed+delta, 
-                          (total_bytes_sent/(duration.rel_value / 1000)/1024), 
-                          total_bytes_sent/(duration.rel_value / 1000));
-          ok = 1;
-          failed_measurement_counter--;
-          if (failed_measurement_counter < 0)
-          {
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  "\nQuota measurement failed and no free strike: %i\n",failed_measurement_counter);
-                  end();
-                  return;
-          }
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                                  "\nQuota measurement failed and %i free strikes\n",failed_measurement_counter);
-  }
+                      "\nQuota measurement failed and no free strike: %i\n",failed_measurement_counter);
+          end();
+          return;
+        }
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "\nQuota measurement failed and %i free strikes\n",failed_measurement_counter);
+    }
   else
-  {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                          "\nQuota compliance ok: \n"\
-                          "Quota allowed: %10llu kB/s\n"\
-                          "Throughput   : %10llu kB/s\n", (quota_allowed / (1024)) , (total_bytes_sent/(duration.rel_value / 1000)/1024));
-          if (failed_measurement_counter < 2)
-                  failed_measurement_counter++;
-          ok = 0;
-  }
-
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "\nQuota compliance ok: \n"                   \
+                  "Quota allowed: %10llu kB/s\n"                        \
+                  "Throughput   : %10llu kB/s\n",
+                  (quota_allowed / (1024)), 
+                  (total_bytes_sent/(duration.rel_value / 1000)/1024));
+      if (failed_measurement_counter < 2)
+        failed_measurement_counter++;
+      ok = 0;
+    }
+  
   if ((quota_allowed) > (2 *(total_bytes_sent/(duration.rel_value / 1000))))
-  {
-          if (failed_measurement_counter < 2)
-                  failed_measurement_counter++;
-          if (strike_counter == 2)
-          {
-                  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                                  "Maximum transmission rate reached, stopping test\n");
-                  end();
-                  return;
-          }
-  }
-  else
-  {
-          strike_counter = 0;
-  }
-
-  if (quota_allowed == MEASUREMENT_MAX_QUOTA)
-  {
+    {
+      if (failed_measurement_counter < 2)
+        failed_measurement_counter++;
+      if (strike_counter == 2)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      "Maximum transmission rate reached, stopping test\n");
           end();
           return;
-  }
+        }
+    }
+  else
+    {
+      strike_counter = 0;
+    }
+  
+  if (quota_allowed == MEASUREMENT_MAX_QUOTA)
+    {
+      end();
+      return;
+    }
   if (is_asymmetric_send_constant == GNUNET_YES)
-  {
-   if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
-          measure (current_quota_p1 * 2, MEASUREMENT_MAX_QUOTA);
-   else
-           measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
-  }
+    {
+      if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
+        measure (current_quota_p1 * 2, MEASUREMENT_MAX_QUOTA);
+      else
+        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
+    }
   else if (is_asymmetric_recv_constant == GNUNET_YES)
-  {
-   if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
-          measure (MEASUREMENT_MAX_QUOTA, current_quota_p2 * 2);
-   else
-           measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
-  }
+    {
+      if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
+        measure (MEASUREMENT_MAX_QUOTA, current_quota_p2 * 2);
+      else
+        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
+    }
   else
-  {
-   if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
-          measure ((current_quota_p1) * 2, (current_quota_p2) * 2);
-   else
-           measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
-  }
+    {
+      if ((quota_allowed * 2) < MEASUREMENT_MAX_QUOTA)
+        measure ((current_quota_p1) * 2, (current_quota_p2) * 2);
+      else
+        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MAX_QUOTA);
+    }
 }
 
-static void measure (unsigned long long quota_p1, unsigned long long quota_p2 )
+static void 
+measure (unsigned long long quota_p1, unsigned long long quota_p2)
 {
-          current_quota_p1 = quota_p1;
-          current_quota_p2 = quota_p2;
+  current_quota_p1 = quota_p1;
+  current_quota_p2 = quota_p2;
 #if VERBOSE
   if ((is_asymmetric_send_constant == GNUNET_YES) || (is_asymmetric_recv_constant == GNUNET_YES))
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting transport level measurement for %u seconds, receiving peer quota %llu kB/s, sending peer quota %llu kB/s\n", MEASUREMENT_INTERVALL.rel_value / 1000 , current_quota_p1 / 1024, current_quota_p2 / 1024);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting transport level measurement for %u seconds, receiving peer quota %llu kB/s, sending peer quota %llu kB/s\n",
+                MEASUREMENT_INTERVALL.rel_value / 1000 ,
+                current_quota_p1 / 1024,
+                current_quota_p2 / 1024);
   else
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting transport level measurement for %u seconds, symmetric quota %llu kB/s\n", MEASUREMENT_INTERVALL.rel_value / 1000 , current_quota_p2 / 1024);
-
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting transport level measurement for %u seconds, symmetric quota %llu kB/s\n", 
+                MEASUREMENT_INTERVALL.rel_value / 1000,
+                current_quota_p2 / 1024);
+  
 #endif
-                GNUNET_TRANSPORT_set_quota (p1.th,
-                                            &p2.id,
-                                            GNUNET_BANDWIDTH_value_init (current_quota_p1),
-                                            GNUNET_BANDWIDTH_value_init (current_quota_p1));
-                GNUNET_TRANSPORT_set_quota (p2.th,
-                                            &p1.id,
-                                            GNUNET_BANDWIDTH_value_init (current_quota_p2),
-                                            GNUNET_BANDWIDTH_value_init (current_quota_p2));
-                GNUNET_SCHEDULER_cancel (die_task);
-                die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                                   &end_badly,
-                                                   NULL);
-                if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
-                  GNUNET_SCHEDULER_cancel (measurement_counter_task);
-                measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                                                   &measurement_counter,
-                                                                   NULL);
-                measurement_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
+  GNUNET_TRANSPORT_set_quota (p1.th,
+                              &p2.id,
+                              GNUNET_BANDWIDTH_value_init (current_quota_p1),
+                              GNUNET_BANDWIDTH_value_init (current_quota_p1));
+  GNUNET_TRANSPORT_set_quota (p2.th,
+                              &p1.id,
+                              GNUNET_BANDWIDTH_value_init (current_quota_p2),
+                              GNUNET_BANDWIDTH_value_init (current_quota_p2));
+  GNUNET_SCHEDULER_cancel (die_task);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                           &end_badly,
+                                           NULL);
+  if (measurement_counter_task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (measurement_counter_task);
+  measurement_counter_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                                           &measurement_counter,
+                                                           NULL);
+  measurement_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
                                                    &measurement_end,
                                                    NULL);
-                total_bytes_sent = 0;
-                last_msg_sent = 0;
-                last_msg_recv = 0;
-                measurement_running = GNUNET_YES;
-                start_time = GNUNET_TIME_absolute_get ();
-
-                if (transmit_handle != NULL)
-                          GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
-                transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                                                                          &p1.id,
-                                                                                          get_size (), 0, SEND_TIMEOUT,
-                                                                                          &notify_ready,
-                                                                                          NULL);
+  total_bytes_sent = 0;
+  last_msg_sent = 0;
+  last_msg_recv = 0;
+  measurement_running = GNUNET_YES;
+  start_time = GNUNET_TIME_absolute_get ();
+  
+  if (transmit_handle != NULL)
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel(transmit_handle);
+  transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
+                                                            &p1.id,
+                                                            get_size (), 0, SEND_TIMEOUT,
+                                                            &notify_ready,
+                                                            NULL);
+}
+
+
+static void
+exchange_hello_last (void *cls,
+                     const struct GNUNET_MessageHeader *message)
+{
+  struct PeerContext *me = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Exchanging HELLO of size %d with peer (%s)!\n", 
+              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
+              GNUNET_i2s (&me->id));
+  GNUNET_assert (message != NULL);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
+                                      message, &me->id));
+  GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
+}
+
+
+
+static void
+exchange_hello (void *cls,
+                const struct GNUNET_MessageHeader *message)
+{
+  struct PeerContext *me = cls;
+
+  GNUNET_assert (message != NULL);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
+                                      message, &me->id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Exchanging HELLO of size %d from peer %s!\n", 
+              (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
+              GNUNET_i2s (&me->id));
+  GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 }
 
+
 static void
 notify_connect (void *cls,
                 const struct GNUNET_PeerIdentity *peer,
                 const struct GNUNET_TRANSPORT_ATS_Information *ats, uint32_t ats_count)
-{
-  if (cls == &p1)
+{ 
+  connected++;
+ if (cls == &p1)
     {
 #if DEBUG_CONNECTIONS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer 1 `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Peer 1 `%4s' connected to us (%p)!\n", 
+                  GNUNET_i2s (peer), 
+                  cls);
 #endif
-          connected++;
     }
   else
     {
 #if DEBUG_CONNECTIONS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer 2 `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Peer 2 `%4s' connected to us (%p)!\n", 
+                  GNUNET_i2s (peer), 
+                  cls);
 #endif
-      connected++;
     }
   if (connected == 2)
     {
-           if (is_asymmetric_send_constant == GNUNET_YES)
-                   measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MAX_QUOTA);
-           else if (is_asymmetric_recv_constant == GNUNET_YES)
-                   measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MIN_QUOTA);
-           else
-                   measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MIN_QUOTA);
+      GNUNET_SCHEDULER_cancel (tct);
+      tct = GNUNET_SCHEDULER_NO_TASK;
+      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+      if (is_asymmetric_send_constant == GNUNET_YES)
+        measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MAX_QUOTA);
+      else if (is_asymmetric_recv_constant == GNUNET_YES)
+        measure (MEASUREMENT_MAX_QUOTA, MEASUREMENT_MIN_QUOTA);
+      else
+        measure (MEASUREMENT_MIN_QUOTA, MEASUREMENT_MIN_QUOTA);
     }
 }
 
@@ -586,6 +642,7 @@ notify_connect (void *cls,
 static void
 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
+  connected--;
 #if DEBUG_CONNECTIONS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Peer `%4s' disconnected (%p)!\n",
@@ -617,56 +674,24 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   GNUNET_assert (p->th != NULL);
 }
 
-static size_t
-notify_ready_connect (void *cls, size_t size, void *buf)
-{
-  return 0;
-}
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+try_connect (void *cls,
+             const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct PeerContext *me = cls;
-
-  GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, me);
-
-  GNUNET_assert (ok >= 3);
-  OKPP;
-  GNUNET_assert (message != NULL);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
-                                      message, &me->id));
-
-  GNUNET_assert(NULL != (transmit_handle = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                          &p1.id,
-                                          sizeof (struct GNUNET_MessageHeader), 0,
-                                          TIMEOUT,
-                                          &notify_ready_connect,
-                                          NULL)));
-
-  /* both HELLOs exchanged, get ready to test transmission! */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Asking peers to connect...\n");
+  GNUNET_TRANSPORT_try_connect (p2.th,
+                                &p1.id);
+  GNUNET_TRANSPORT_try_connect (p1.th,
+                                &p2.id);
+  tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                      &try_connect,
+                                      NULL);
 }
 
 
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
-{
-  struct PeerContext *me = cls;
-
-  GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, me);
-  GNUNET_assert (ok >= 2);
-  OKPP;
-  GNUNET_assert (message != NULL);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
-                                      message, &me->id));
-  GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
-  GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
-}
-
-static void
 run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
@@ -683,67 +708,85 @@ run (void *cls,
 
   if (is_tcp)
     {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (receiver quota constant) for TCP transport plugin\n");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (sender quota constant) for TCP transport plugin\n");
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing symmetric quota compliance for TCP transport plugin\n");
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Testing asymmetric quota compliance (receiver quota constant) for TCP transport plugin\n");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (sender quota constant) for TCP transport plugin\n");
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Testing symmetric quota compliance for TCP transport plugin\n");
       setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
       setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
     }
   else if (is_http)
     {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (receiver quota constant) for HTTP transport plugin\n");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (sender quota constant) for HTTP transport plugin\n");
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing symmetric quota compliance for HTTP transport plugin\n");
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (receiver quota constant) for HTTP transport plugin\n");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (sender quota constant) for HTTP transport plugin\n");
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing symmetric quota compliance for HTTP transport plugin\n");
       setup_peer (&p1, "test_quota_compliance_http_peer1.conf");
       setup_peer (&p2, "test_quota_compliance_http_peer2.conf");
     }
   else if (is_https)
     {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (receiver quota constant) for HTTPS transport plugin\n");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (sender quota constant) for HTTPS transport plugin\n");
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing symmetric quota compliance for HTTPS transport plugin\n");
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (receiver quota constant) for HTTPS transport plugin\n");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (sender quota constant) for HTTPS transport plugin\n");
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing symmetric quota compliance for HTTPS transport plugin\n");
       setup_peer (&p1, "test_quota_compliance_https_peer1.conf");
       setup_peer (&p2, "test_quota_compliance_https_peer2.conf");
     }
   else if (is_udp)
     {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (receiver quota constant) for UDP transport plugin\n");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (sender quota constant) for UDP transport plugin\n");
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing symmetric quota compliance for UDP transport plugin\n");
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (receiver quota constant) for UDP transport plugin\n");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (sender quota constant) for UDP transport plugin\n");
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing symmetric quota compliance for UDP transport plugin\n");
       setup_peer (&p1, "test_quota_compliance_udp_peer1.conf");
       setup_peer (&p2, "test_quota_compliance_udp_peer2.conf");
     }
   else if (is_unix)
     {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (receiver quota constant) for UNIX transport plugin\n");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (sender quota constant) for UNIX transport plugin\n");
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing symmetric quota compliance for UNIX transport plugin\n");
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (receiver quota constant) for UNIX transport plugin\n");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (sender quota constant) for UNIX transport plugin\n");
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing symmetric quota compliance for UNIX transport plugin\n");
       setup_peer (&p1, "test_quota_compliance_unix_peer1.conf");
       setup_peer (&p2, "test_quota_compliance_unix_peer2.conf");
     }
   else if (is_tcp_nat)
     {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (receiver quota constant) for TCP NAT transport plugin\n");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing asymmetric quota compliance (sender quota constant) for TCP NAT transport plugin\n");
-          else
-                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing symmetric quota compliance for TCP NAT transport plugin\n");
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Testing asymmetric quota compliance (receiver quota constant) for TCP NAT transport plugin\n");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing asymmetric quota compliance (sender quota constant) for TCP NAT transport plugin\n");
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                    "Testing symmetric quota compliance for TCP NAT transport plugin\n");
       setup_peer (&p1, "test_quota_compliance_tcp_peer1.conf");
       setup_peer (&p2, "test_quota_compliance_tcp_peer2.conf");
     }
@@ -753,8 +796,11 @@ run (void *cls,
   GNUNET_assert(p1.th != NULL);
   GNUNET_assert(p2.th != NULL);
   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
+  GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
+  tct = GNUNET_SCHEDULER_add_now (&try_connect, NULL);
 }
 
+
 int
 main (int argc, char *argv[])
 {
@@ -789,67 +835,67 @@ main (int argc, char *argv[])
 
   if (strstr(argv[0], "asymmetric_recv") != NULL)
   {
-      is_asymmetric_recv_constant = GNUNET_YES;
+    is_asymmetric_recv_constant = GNUNET_YES;
   }
   else
-          is_asymmetric_recv_constant = GNUNET_NO;
+    is_asymmetric_recv_constant = GNUNET_NO;
   if (strstr(argv[0], "asymmetric_send") != NULL)
-  {
+    {
       is_asymmetric_send_constant = GNUNET_YES;
-  }
+    }
   else
-          is_asymmetric_send_constant = GNUNET_NO;
-
+    is_asymmetric_send_constant = GNUNET_NO;
+  
   char * logger;
   if (is_tcp == GNUNET_YES)
-  {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_recv_constant");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_send_constant");
-          else
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","symmetric");
-  }
+    {
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_recv_constant");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","asymmetric_send_constant");
+      else
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","tcp","symmetric");
+    }
   else if (is_udp == GNUNET_YES)
-  {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_recv_constant");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_send_constant");
-          else
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","symmetric");
-  }
+    {
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_recv_constant");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","asymmetric_send_constant");
+      else
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","udp","symmetric");
+    }
   else if (is_unix == GNUNET_YES)
-  {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_recv_constant");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_send_constant");
-          else
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","symmetric");
-  }
+    {
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_recv_constant");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","asymmetric_send_constant");
+      else
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","unix","symmetric");
+    }
   else if (is_http == GNUNET_YES)
-  {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_recv_constant");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_send_constant");
-          else
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","symmetric");
-  }
+    {
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_recv_constant");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","asymmetric_send_constant");
+      else
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","http","symmetric");
+    }
   else if (is_https == GNUNET_YES)
-  {
-          if (is_asymmetric_recv_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_recv_constant");
-          else if (is_asymmetric_send_constant == GNUNET_YES)
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_send_constant");
-          else
-                  GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","symmetric");
-  }
+    {
+      if (is_asymmetric_recv_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_recv_constant");
+      else if (is_asymmetric_send_constant == GNUNET_YES)
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","asymmetric_send_constant");
+      else
+        GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","https","symmetric");
+    }
   else
-  {
-          GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","noplugin","none");
-  }
+    {
+      GNUNET_asprintf(&logger, "test-quota-compliance-%s-%s","noplugin","none");
+    }
 
   GNUNET_DISK_directory_remove ("/tmp/test_quota_compliance_peer1");
   GNUNET_DISK_directory_remove ("/tmp/test_quota_compliance_peer2");