Merge branch 'master' of git+ssh://gnunet.org/gnunet

3 files changed, 315 insertions, 286 deletions

diff --git a/configure.ac b/configure.ac
index 2f1184296..68cae8c0e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1261,7 +1261,7 @@ gl_LIBUNISTRING
 AS_IF([test $HAVE_LIBUNISTRING != yes],
       [AC_MSG_ERROR([GNUnet requires libunistring])])
 
-AX_COMPARE_VERSION([$LIBUNISTRING_VERSION],[le],[0.9.1.1],
+AS_VERSION_COMPARE([$LIBUNISTRING_VERSION],[0.9.1.1],
   [AC_MSG_ERROR([GNUnet requires libunistring >= 0.9.1.1])])
 
 AC_CHECK_HEADERS([unistr.h],
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c
index 2e09bc9d2..415dc4b48 100644
--- a/src/transport/gnunet-communicator-udp.c
+++ b/src/transport/gnunet-communicator-udp.c
@@ -574,6 +574,22 @@ struct SenderAddress
    * sender_destroy already called on sender.
    */
   int sender_destroy_called;
+
+
+  /**
+   * ID of kce working queue task
+   */
+  struct GNUNET_SCHEDULER_Task *kce_task;
+
+  /**
+   * ID of kce rekey working queue task
+   */
+  struct GNUNET_SCHEDULER_Task *kce_task_rekey;
+
+  /**
+   * Is the kce_task finished?
+   */
+  int kce_task_finished;
 };
 
 
@@ -789,21 +805,6 @@ static struct GNUNET_SCHEDULER_Task *read_task;
 static struct GNUNET_SCHEDULER_Task *timeout_task;
 
 /**
- * ID of kce working queue task
- */
-static struct GNUNET_SCHEDULER_Task *kce_task;
-
-/**
- * ID of kce rekey working queue task
- */
-static struct GNUNET_SCHEDULER_Task *kce_task_rekey;
-
-/**
- * Is the kce_task finished?
- */
-static int kce_task_finished = GNUNET_NO;
-
-/**
  * ID of master broadcast task
  */
 static struct GNUNET_SCHEDULER_Task *broadcast_task;
@@ -1744,7 +1745,8 @@ static void
 kce_generate_cb (void *cls)
 {
   struct SharedSecret *ss = cls;
-  kce_task = NULL;
+
+  ss->sender->kce_task = NULL;
 
   if (((GNUNET_NO == ss->sender->rekeying) && (ss->sender->acks_available <
                                                KCN_TARGET) ) ||
@@ -1759,16 +1761,17 @@ kce_generate_cb (void *cls)
     for (int i = 0; i < GENERATE_AT_ONCE; i++)
       kce_generate (ss, ++ss->sequence_allowed);
 
-    kce_task = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
-                                             kce_generate_cb,
-                                             ss);
+    ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
+      WORKING_QUEUE_INTERVALL,
+      kce_generate_cb,
+      ss);
   }
   else
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "We have enough keys.\n");
     ss_finished = ss;
-    kce_task_finished = GNUNET_YES;
+    ss->sender->kce_task_finished = GNUNET_YES;
   }
 
 
@@ -1779,9 +1782,10 @@ static void
 kce_generate_rekey_cb (void *cls)
 {
   struct SharedSecret *ss = cls;
-  kce_task_rekey = NULL;
 
-  if (NULL == kce_task)
+  ss->sender->kce_task_rekey = NULL;
+
+  if (NULL == ss->sender->kce_task)
   {
 
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1791,16 +1795,18 @@ kce_generate_rekey_cb (void *cls)
     for (int i = 0; i < GENERATE_AT_ONCE; i++)
       kce_generate (ss, ++ss->sequence_allowed);
 
-    kce_task = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
-                                             kce_generate_cb,
-                                             ss);
-    kce_task_rekey = NULL;
+    ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
+      WORKING_QUEUE_INTERVALL,
+      kce_generate_cb,
+      ss);
+    ss->sender->kce_task_rekey = NULL;
   }
   else
   {
-    kce_task_rekey = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
-                                                   kce_generate_rekey_cb,
-                                                   ss);
+    ss->sender->kce_task_rekey = GNUNET_SCHEDULER_add_delayed (
+      WORKING_QUEUE_INTERVALL,
+      kce_generate_rekey_cb,
+      ss);
   }
 }
 
@@ -1817,6 +1823,14 @@ kce_generate_rekey_cb (void *cls)
 static void
 consider_ss_ack (struct SharedSecret *ss, int initial)
 {
+  struct GNUNET_SCHEDULER_Task *kce_task_rekey;
+  struct GNUNET_SCHEDULER_Task *kce_task;
+  int kce_task_finished;
+
+  kce_task_rekey = ss->sender->kce_task_rekey;
+  kce_task_finished = ss->sender->kce_task_finished;
+  kce_task = ss->sender->kce_task;
+
   GNUNET_assert (NULL != ss->sender);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Considering SS UDPAck %s\n",
@@ -1886,6 +1900,7 @@ consider_ss_ack (struct SharedSecret *ss, int initial)
     kce_task = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
                                              kce_generate_cb,
                                              ss);
+    kce_task_finished = GNUNET_NO;
 
   }
   else if ((NULL == kce_task_rekey) && (GNUNET_YES ==
@@ -3247,6 +3262,18 @@ get_sender_delete_it (void *cls,
 
   (void) cls;
   (void) target;
+
+  if (NULL != sender->kce_task_rekey)
+  {
+    GNUNET_SCHEDULER_cancel (sender->kce_task_rekey);
+    sender->kce_task_rekey = NULL;
+  }
+  if (NULL != sender->kce_task)
+  {
+    GNUNET_SCHEDULER_cancel (sender->kce_task);
+    sender->kce_task = NULL;
+  }
+
   sender_destroy (sender);
   return GNUNET_OK;
 }
@@ -3274,16 +3301,6 @@ do_shutdown (void *cls)
     GNUNET_SCHEDULER_cancel (broadcast_task);
     broadcast_task = NULL;
   }
-  if (NULL != kce_task_rekey)
-  {
-    GNUNET_SCHEDULER_cancel (kce_task_rekey);
-    kce_task_rekey = NULL;
-  }
-  if (NULL != kce_task)
-  {
-    GNUNET_SCHEDULER_cancel (kce_task);
-    kce_task = NULL;
-  }
   if (NULL != timeout_task)
   {
     GNUNET_SCHEDULER_cancel (timeout_task);
diff --git a/src/transport/test_communicator_basic.c b/src/transport/test_communicator_basic.c
index ffc21e47a..98b49012a 100644
--- a/src/transport/test_communicator_basic.c
+++ b/src/transport/test_communicator_basic.c
@@ -326,46 +326,128 @@ get_peer_nr (void *cls, unsigned int get_the_other_one)
 }
 
 static void
-latency_timeout (void *cls)
+process_statistics_box_done (void *cls, int success)
 {
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
 
+  if (NULL != box_stats[peer_nr])
+    box_stats[peer_nr] = NULL;
+  if (NULL == rekey_stats[peer_nr])
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+static void
+process_statistics_rekey_done (void *cls, int success)
+{
   struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
   unsigned int peer_nr;
-  size_t num_sent = 0;
-  size_t num_received = 0;
 
   peer_nr = get_peer_nr_from_tc (tc_h);
-  to_task[peer_nr] = NULL;
-  if (GNUNET_TIME_absolute_get_remaining (timeout[peer_nr]).rel_value_us > 0)
+
+  if (NULL != rekey_stats[peer_nr])
+    rekey_stats[peer_nr] = NULL;
+  if (NULL == box_stats[peer_nr])
   {
-    to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
-                                                &latency_timeout,
-                                                cls);
-    return;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished\n");
+    GNUNET_SCHEDULER_shutdown ();
   }
-  switch (phase[peer_nr])
+}
+
+static int
+process_statistics (void *cls,
+                    const char *subsystem,
+                    const char *name,
+                    uint64_t value,
+                    int is_persistent)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Statistic: Name %s and value %lu\n",
+              name,
+              value);
+  if ((0 == strcmp ("rekey", test_name)) && (0 == strcmp (
+                                               "# rekeying successful",
+                                               name)) && (0 == value))
   {
-  case TP_INIT:
-    GNUNET_assert (0);
-    break;
-  case TP_BURST_SHORT:
-    num_sent = num_sent_short[peer_nr];
-    num_received = num_received_short[peer_nr];
-    break;
-  case TP_BURST_LONG:
-    num_sent = num_sent_long[peer_nr];
-    num_received = num_received_long[peer_nr];
-    break;
-  case TP_SIZE_CHECK:
-    num_sent = num_sent_size[peer_nr];
-    num_received = num_received_size[peer_nr];
-    break;
+    ret = 2;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No successful rekeying!\n");
+    GNUNET_SCHEDULER_shutdown ();
   }
-  LOG (GNUNET_ERROR_TYPE_ERROR,
-       "Latency too high. Test failed. (Phase: %d. Sent: %lu, Received: %lu)\n",
-       phase[peer_nr], num_sent, num_received);
-  ret = 2;
-  GNUNET_SCHEDULER_shutdown ();
+  if ((0 == strcmp ("backchannel", test_name)) &&
+      (0 == strcmp (
+         "# messages decrypted with BOX",
+         name))
+      && (9000 > value))
+  {
+    ret = 2;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Not enough BOX messages!\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  if ((0 == strcmp ("rekey", test_name)) &&
+      (0 == strcmp (
+         "# messages decrypted with BOX",
+         name))
+      && (6000 > value))
+  {
+    ret = 2;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Not enough BOX messages!\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  return GNUNET_OK;
+}
+
+static void
+short_test (void *cls);
+
+static void
+short_test_cb (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+  char *payload;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "short_test_cb %u/%u for peer %u and handle %p\n",
+       (unsigned int) num_sent_short[peer_nr],
+       (unsigned int) num_received_short[peer_nr],
+       peer_nr,
+       tc_h);
+  payload = make_payload (SHORT_MESSAGE_SIZE);
+  num_sent_short[peer_nr]++;
+  GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h,
+                                                        (burst_packets_short ==
+                                                         num_sent_short[peer_nr])
+                                                        ? NULL
+                                                        : &short_test,
+                                                        cls,
+                                                        payload,
+                                                        SHORT_MESSAGE_SIZE);
+  GNUNET_free (payload);
+  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER));
+}
+
+static void
+short_test (void *cls)
+{
+  GNUNET_SCHEDULER_add_delayed (delay_short,
+                                &short_test_cb,
+                                cls);
 }
 
 static void
@@ -403,7 +485,6 @@ size_test (void *cls)
       TIMEOUT_MULTIPLIER));
 }
 
-
 static void
 long_test (void *cls);
 
@@ -446,161 +527,6 @@ long_test (void *cls)
                                 cls);
 }
 
-
-static void
-short_test (void *cls);
-
-
-static void
-short_test_cb (void *cls)
-{
-  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
-  unsigned int peer_nr;
-  char *payload;
-
-  peer_nr = get_peer_nr_from_tc (tc_h);
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "short_test_cb %u/%u for peer %u and handle %p\n",
-       (unsigned int) num_sent_short[peer_nr],
-       (unsigned int) num_received_short[peer_nr],
-       peer_nr,
-       tc_h);
-  payload = make_payload (SHORT_MESSAGE_SIZE);
-  num_sent_short[peer_nr]++;
-  GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h,
-                                                        (burst_packets_short ==
-                                                         num_sent_short[peer_nr])
-                                                        ? NULL
-                                                        : &short_test,
-                                                        cls,
-                                                        payload,
-                                                        SHORT_MESSAGE_SIZE);
-  GNUNET_free (payload);
-  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
-    GNUNET_TIME_relative_multiply (
-      GNUNET_TIME_UNIT_SECONDS,
-      TIMEOUT_MULTIPLIER));
-}
-
-
-static void
-short_test (void *cls)
-{
-  GNUNET_SCHEDULER_add_delayed (delay_short,
-                                &short_test_cb,
-                                cls);
-}
-
-
-/* static int test_prepared = GNUNET_NO; */
-
-/* This helps establishing the backchannel */
-/* static void */
-/* prepare_test (void *cls) */
-/* { */
-/*   char *payload; */
-
-/*   if (GNUNET_YES == test_prepared) */
-/*   { */
-/*     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, */
-/*                                   &short_test, */
-/*                                   NULL); */
-/*     return; */
-/*   } */
-/*   test_prepared = GNUNET_YES; */
-/*   payload = make_payload (SHORT_MESSAGE_SIZE); */
-/*   GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, */
-/*                                                         &prepare_test, */
-/*                                                         NULL, */
-/*                                                         payload, */
-/*                                                         SHORT_MESSAGE_SIZE); */
-/*   GNUNET_free (payload); */
-/* } */
-
-static void
-process_statistics_box_done (void *cls, int success)
-{
-  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
-  unsigned int peer_nr;
-
-  peer_nr = get_peer_nr_from_tc (tc_h);
-
-  if (NULL != box_stats[peer_nr])
-    box_stats[peer_nr] = NULL;
-  if (NULL == rekey_stats[peer_nr])
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Finished\n");
-    GNUNET_SCHEDULER_shutdown ();
-  }
-}
-
-
-static void
-process_statistics_rekey_done (void *cls, int success)
-{
-  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
-  unsigned int peer_nr;
-
-  peer_nr = get_peer_nr_from_tc (tc_h);
-
-  if (NULL != rekey_stats[peer_nr])
-    rekey_stats[peer_nr] = NULL;
-  if (NULL == box_stats[peer_nr])
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Finished\n");
-    GNUNET_SCHEDULER_shutdown ();
-  }
-}
-
-
-static int
-process_statistics (void *cls,
-                    const char *subsystem,
-                    const char *name,
-                    uint64_t value,
-                    int is_persistent)
-{
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Statistic: Name %s and value %lu\n",
-              name,
-              value);
-  if ((0 == strcmp ("rekey", test_name)) && (0 == strcmp (
-                                               "# rekeying successful",
-                                               name)) && (0 == value))
-  {
-    ret = 2;
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "No successful rekeying!\n");
-    GNUNET_SCHEDULER_shutdown ();
-  }
-  if ((0 == strcmp ("backchannel", test_name)) &&
-      (0 == strcmp (
-         "# messages decrypted with BOX",
-         name))
-      && (9000 > value))
-  {
-    ret = 2;
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Not enough BOX messages!\n");
-    GNUNET_SCHEDULER_shutdown ();
-  }
-  if ((0 == strcmp ("rekey", test_name)) &&
-      (0 == strcmp (
-         "# messages decrypted with BOX",
-         name))
-      && (6000 > value))
-  {
-    ret = 2;
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Not enough BOX messages!\n");
-    GNUNET_SCHEDULER_shutdown ();
-  }
-  return GNUNET_OK;
-}
-
 static void
 choose_phase (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
 {
@@ -661,8 +587,11 @@ choose_phase (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
     }
     else
     {
-      if (((PEER_A == peer_nr) && finished[PEER_B]) || ((PEER_B == peer_nr) &&
-                                                        finished[PEER_A]))
+      if ((GNUNET_NO == bidirect)|| (((PEER_A == peer_nr) &&
+                                      finished[PEER_B]) || ((PEER_B ==
+                                                             peer_nr) &&
+                                                            finished
+                                                            [PEER_A])))
       {
         LOG (GNUNET_ERROR_TYPE_DEBUG,
              "Finished\n");
@@ -673,6 +602,137 @@ choose_phase (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
   }
 }
 
+static void finish_phase_long (unsigned int peer_nr)
+{
+  static struct GNUNET_TIME_Relative duration;
+
+  duration = GNUNET_TIME_absolute_get_duration (start_long[peer_nr]);
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "Long size packet test  for peer %u done.\n",
+       peer_nr);
+  char *goodput = GNUNET_STRINGS_byte_size_fancy (
+    (long_message_size * num_received_long[peer_nr] * 1000 * 1000)
+    / duration.
+    rel_value_us);
+
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n",
+       (unsigned long) num_received_long[peer_nr],
+       (unsigned long) num_sent_long[peer_nr],
+       (unsigned long long) duration.rel_value_us,
+       goodput,
+       (unsigned long long) avg_latency[peer_nr]);
+  GNUNET_free (goodput);
+  ack[peer_nr] = 0;
+  // phase = TP_SIZE_CHECK;
+  // num_received = 0;
+  // num_sent_long = 0;
+  avg_latency[peer_nr] = 0;
+  // size_test (NULL);
+  phase_long[peer_nr] = GNUNET_NO;
+  choose_phase (get_tc_h (peer_nr));
+}
+
+static void
+finish_phase_short (unsigned int peer_nr)
+{
+  static struct GNUNET_TIME_Relative duration;
+
+  duration = GNUNET_TIME_absolute_get_duration (start_short[peer_nr]);
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "Short size packet test for peer %u done.\n",
+       peer_nr);
+  char *goodput = GNUNET_STRINGS_byte_size_fancy (
+    (SHORT_MESSAGE_SIZE * num_received_short[peer_nr] * 1000 * 1000)
+    / duration.rel_value_us);
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n",
+       (unsigned long) num_received_short[peer_nr],
+       (unsigned long) num_sent_short[peer_nr],
+       (unsigned long long) duration.rel_value_us,
+       goodput,
+       (unsigned long long) avg_latency[peer_nr]);
+  GNUNET_free (goodput);
+  // start_long = GNUNET_TIME_absolute_get ();
+  // phase = TP_BURST_LONG;
+  // num_sent_short = 0;
+  avg_latency[peer_nr] = 0;
+  // num_received = 0;
+  phase_short[peer_nr] = GNUNET_NO;
+  choose_phase (get_tc_h (peer_nr));
+  // long_test (NULL);
+}
+
+static void
+latency_timeout (void *cls)
+{
+
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+  size_t num_sent = 0;
+  size_t num_received = 0;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+  to_task[peer_nr] = NULL;
+
+  switch (phase[peer_nr])
+  {
+  case TP_INIT:
+    GNUNET_assert (0);
+    break;
+  case TP_BURST_SHORT:
+    num_sent = num_sent_short[peer_nr];
+    num_received = num_received_short[peer_nr];
+    if ((num_sent_short[peer_nr] == burst_packets_short) &&
+        (num_received_short[peer_nr] >
+         burst_packets_short
+         / 100
+         *
+         allowed_packet_loss_short) )
+    {
+      finish_phase_short (peer_nr);
+      to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
+                                                  &latency_timeout,
+                                                  cls);
+      return;
+    }
+    break;
+  case TP_BURST_LONG:
+    num_sent = num_sent_long[peer_nr];
+    num_received = num_received_long[peer_nr];
+    if ((num_sent_long[peer_nr] == burst_packets_long) &&
+        (num_received_long[peer_nr] >
+         burst_packets_long
+         / 100
+         *
+         allowed_packet_loss_long) )
+    {
+      finish_phase_long (peer_nr);
+      to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
+                                                  &latency_timeout,
+                                                  cls);
+      return;
+    }
+    break;
+  case TP_SIZE_CHECK:
+    num_sent = num_sent_size[peer_nr];
+    num_received = num_received_size[peer_nr];
+    break;
+  }
+  if (GNUNET_TIME_absolute_get_remaining (timeout[peer_nr]).rel_value_us > 0)
+  {
+    to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
+                                                &latency_timeout,
+                                                cls);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "Latency too high. Test failed. (Phase: %d. Sent: %lu, Received: %lu)\n",
+       phase[peer_nr], num_sent, num_received);
+  ret = 2;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
 /**
  * @brief Handle opening of queue
  *
@@ -812,6 +872,8 @@ load_phase_config ()
   phase_size[1] = phase_size[0];
 }
 
+
+
 /**
  * @brief Handle an incoming message
  *
@@ -829,7 +891,7 @@ incoming_message_cb (
   size_t payload_len)
 {
   unsigned int peer_nr;
-  static struct GNUNET_TIME_Relative duration;
+
 
   peer_nr = get_peer_nr (cls, GNUNET_YES);
 
@@ -854,37 +916,13 @@ incoming_message_cb (
     {
       GNUNET_assert (SHORT_MESSAGE_SIZE == payload_len);
       num_received_short[peer_nr]++;
-      duration = GNUNET_TIME_absolute_get_duration (start_short[peer_nr]);
+
       update_avg_latency (payload, peer_nr);
       if ((num_sent_short[peer_nr] == burst_packets_short) &&
-          (num_received_short[peer_nr] >
-           burst_packets_short
-           / 100
-           *
-           allowed_packet_loss_short) )
+          (num_received_short[peer_nr] ==
+           burst_packets_short))
       {
-        LOG (GNUNET_ERROR_TYPE_MESSAGE,
-             "Short size packet test for peer %u done.\n",
-             peer_nr);
-        char *goodput = GNUNET_STRINGS_byte_size_fancy (
-          (SHORT_MESSAGE_SIZE * num_received_short[peer_nr] * 1000 * 1000)
-          / duration.rel_value_us);
-        LOG (GNUNET_ERROR_TYPE_MESSAGE,
-             "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n",
-             (unsigned long) num_received_short[peer_nr],
-             (unsigned long) num_sent_short[peer_nr],
-             (unsigned long long) duration.rel_value_us,
-             goodput,
-             (unsigned long long) avg_latency[peer_nr]);
-        GNUNET_free (goodput);
-        // start_long = GNUNET_TIME_absolute_get ();
-        // phase = TP_BURST_LONG;
-        // num_sent_short = 0;
-        avg_latency[peer_nr] = 0;
-        // num_received = 0;
-        phase_short[peer_nr] = GNUNET_NO;
-        choose_phase (get_tc_h (peer_nr));
-        // long_test (NULL);
+        finish_phase_short (peer_nr);
       }
       break;
     }
@@ -897,39 +935,13 @@ incoming_message_cb (
         return;   // Ignore
       }
       num_received_long[peer_nr]++;
-      duration = GNUNET_TIME_absolute_get_duration (start_long[peer_nr]);
+
       update_avg_latency (payload, peer_nr);
       if ((num_sent_long[peer_nr] == burst_packets_long) &&
           (num_received_long[peer_nr] >
-           burst_packets_long
-           / 100
-           *
-           allowed_packet_loss_short) )
+           burst_packets_long))
       {
-        LOG (GNUNET_ERROR_TYPE_MESSAGE,
-             "Long size packet test  for peer %u done.\n",
-             peer_nr);
-        char *goodput = GNUNET_STRINGS_byte_size_fancy (
-          (long_message_size * num_received_long[peer_nr] * 1000 * 1000)
-          / duration.
-          rel_value_us);
-
-        LOG (GNUNET_ERROR_TYPE_MESSAGE,
-             "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n",
-             (unsigned long) num_received_long[peer_nr],
-             (unsigned long) num_sent_long[peer_nr],
-             (unsigned long long) duration.rel_value_us,
-             goodput,
-             (unsigned long long) avg_latency[peer_nr]);
-        GNUNET_free (goodput);
-        ack[peer_nr] = 0;
-        // phase = TP_SIZE_CHECK;
-        // num_received = 0;
-        // num_sent_long = 0;
-        avg_latency[peer_nr] = 0;
-        // size_test (NULL);
-        phase_long[peer_nr] = GNUNET_NO;
-        choose_phase (get_tc_h (peer_nr));
+        finish_phase_long (peer_nr);
       }
       break;
     }