indentation

1 files changed, 375 insertions, 378 deletions

diff --git a/src/transport/test_transport_api_unreliability.c b/src/transport/test_transport_api_unreliability.c
index e7cb00274..88df23eb4 100644
--- a/src/transport/test_transport_api_unreliability.c
+++ b/src/transport/test_transport_api_unreliability.c
@@ -50,7 +50,7 @@
  * 'MAX_PENDING' in 'gnunet-service-transport.c', otherwise
  * messages may be dropped even for a reliable transport.
  */
-#define TOTAL_MSGS (1024 * 3) /* Total messages should be divisible by 8, so we can make a nice bitmap */
+#define TOTAL_MSGS (1024 * 3)   /* Total messages should be divisible by 8, so we can make a nice bitmap */
 
 /**
  * How long until we give up on transmitting the message?
@@ -91,7 +91,7 @@ static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
 static GNUNET_SCHEDULER_TaskIdentifier tct;
 
-struct GNUNET_TRANSPORT_TransmitHandle * th_p2;
+struct GNUNET_TRANSPORT_TransmitHandle *th_p2;
 
 static char *key_file_p1;
 static char *cert_file_p1;
@@ -123,11 +123,13 @@ set_bit (unsigned int bitIdx)
 {
   size_t arraySlot;
   unsigned int targetBit;
-  if (bitIdx >= sizeof(bitmap) * 8)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "tried to set bit %d of %d(!?!?)\n", bitIdx, sizeof(bitmap) * 8);
-      return;
-    }
+
+  if (bitIdx >= sizeof (bitmap) * 8)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "tried to set bit %d of %d(!?!?)\n",
+                bitIdx, sizeof (bitmap) * 8);
+    return;
+  }
   arraySlot = bitIdx / 8;
   targetBit = (1L << (bitIdx % 8));
   bitmap[arraySlot] |= targetBit;
@@ -144,10 +146,11 @@ int
 get_bit (const char *map, unsigned int bit)
 {
   if (bit >= TOTAL_MSGS)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "get bit %d of %d(!?!?)\n", bit, sizeof(bitmap) * 8);
-      return 0;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "get bit %d of %d(!?!?)\n", bit,
+                sizeof (bitmap) * 8);
+    return 0;
+  }
   return ((map)[bit >> 3] & (1 << (bit & 7))) > 0;
 }
 
@@ -161,13 +164,13 @@ end ()
 
   result = 0;
   for (i = 0; i < TOTAL_MSGS; i++)
+  {
+    if (get_bit (bitmap, i) == 0)
     {
-      if (get_bit(bitmap, i) == 0)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Did not receive message %d\n", i);
-          result = -1;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Did not receive message %d\n", i);
+      result = -1;
     }
+  }
 
   if (GNUNET_SCHEDULER_NO_TASK != die_task)
     GNUNET_SCHEDULER_cancel (die_task);
@@ -176,22 +179,22 @@ end ()
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
 #endif
   if (th_p2 != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th_p2);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
   th_p2 = NULL;
 
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transports disconnected, returning success!\n");
+              "Transports disconnected, returning success!\n");
 #endif
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
-  GNUNET_asprintf(&value_name, "unreliable_%s", test_name);
-  GAUGER ("TRANSPORT", value_name, (int)(total_bytes * 1000 / 1024 /delta), "kb/s");
-  GNUNET_free(value_name);
+  GNUNET_asprintf (&value_name, "unreliable_%s", test_name);
+  GAUGER ("TRANSPORT", value_name, (int) (total_bytes * 1000 / 1024 / delta),
+          "kb/s");
+  GNUNET_free (value_name);
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
   ok = result;
 
 }
@@ -203,22 +206,23 @@ end_unreliably ()
   int i;
   int num_failed;
   char *value_name;
+
   num_failed = 0;
   for (i = 0; i < TOTAL_MSGS; i++)
+  {
+    if (get_bit (bitmap, i) == 0)
     {
-      if (get_bit(bitmap, i) == 0)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Did not receive message %d\n", i);
-          num_failed++;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Did not receive message %d\n", i);
+      num_failed++;
     }
+  }
 
   die_task = GNUNET_SCHEDULER_NO_TASK;
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
 #endif
   if (th_p2 != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th_p2);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
 
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
@@ -228,15 +232,16 @@ end_unreliably ()
 #endif
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
-  GNUNET_asprintf(&value_name, "unreliable_%s", test_name);
-  GAUGER ("TRANSPORT", value_name, (int)(total_bytes * 1000 / 1024 /delta), "kb/s");
-  GNUNET_free(value_name);
-  GNUNET_asprintf(&value_name, "unreliable_failed_%s", test_name);
-  GAUGER ("TRANSPORT", value_name, (int)num_failed, "msgs");
-  GNUNET_free(value_name);
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Had %d failed messages!\n", num_failed);
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
+  GNUNET_asprintf (&value_name, "unreliable_%s", test_name);
+  GAUGER ("TRANSPORT", value_name, (int) (total_bytes * 1000 / 1024 / delta),
+          "kb/s");
+  GNUNET_free (value_name);
+  GNUNET_asprintf (&value_name, "unreliable_failed_%s", test_name);
+  GAUGER ("TRANSPORT", value_name, (int) num_failed, "msgs");
+  GNUNET_free (value_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Had %d failed messages!\n",
+              num_failed);
   ok = 0;
 
 }
@@ -259,16 +264,15 @@ stop_arm (struct PeerContext *p)
 
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+exchange_hello_last (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
   GNUNET_assert (message != NULL);
   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));
+              "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 (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &me->id));
@@ -278,8 +282,7 @@ exchange_hello_last (void *cls,
 
 
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
+exchange_hello (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *me = cls;
 
@@ -288,52 +291,47 @@ exchange_hello (void *cls,
                  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));
+              "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
-end_badly (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (test_failed == GNUNET_NO)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Testcase timeout\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase timeout\n");
   else
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Reliability failed: Last message sent %u, Next message scheduled %u, Last message received %u, Message expected %u\n",
-                msg_sent,
-                msg_scheduled,
-                msg_recv,
-                msg_recv_expected);
-  
+                "Reliability failed: Last message sent %u, Next message scheduled %u, Last message received %u, Message expected %u\n",
+                msg_sent, msg_scheduled, msg_recv, msg_recv_expected);
+
   GNUNET_break (0);
   if (th_p2 != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(th_p2);
-      th_p2 = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
+    th_p2 = NULL;
+  }
   if (p2_hello_canceled == GNUNET_NO)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
-      p2_hello_canceled = GNUNET_YES;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+    p2_hello_canceled = GNUNET_YES;
+  }
   if (p1_hello_canceled == GNUNET_NO)
-    {
-      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
-      p1_hello_canceled = GNUNET_YES;
-    }
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+    p1_hello_canceled = GNUNET_YES;
+  }
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
   if (GNUNET_SCHEDULER_NO_TASK != tct)
-    {
-      GNUNET_SCHEDULER_cancel (tct);
-      tct = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (tct);
+    tct = GNUNET_SCHEDULER_NO_TASK;
+  }
   ok = 1;
 }
 
@@ -368,63 +366,56 @@ notify_receive (void *cls,
   char cbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
   const struct TestMessage *hdr;
 
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
 
   if (MTYPE != ntohs (message->type))
     return;
   msg_recv_expected = n;
-  msg_recv = ntohl(hdr->num);
-  s = get_size (ntohl(hdr->num));
+  msg_recv = ntohl (hdr->num);
+  s = get_size (ntohl (hdr->num));
 
   if (ntohs (message->size) != s)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  ntohl(hdr->num), s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                ntohl (hdr->num), s, ntohs (message->size), ntohl (hdr->num));
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 
-  memset (cbuf, ntohl(hdr->num), s - sizeof (struct TestMessage));
-  if (0 != memcmp (cbuf,
-                   &hdr[1],
-                   s - sizeof (struct TestMessage)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u with bits %u, but body did not match\n",
-                  ntohl(hdr->num), (unsigned char) n);
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  memset (cbuf, ntohl (hdr->num), s - sizeof (struct TestMessage));
+  if (0 != memcmp (cbuf, &hdr[1], s - sizeof (struct TestMessage)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u with bits %u, but body did not match\n",
+                ntohl (hdr->num), (unsigned char) n);
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 #if VERBOSE
-  if (ntohl(hdr->num) % 5 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got message %u of size %u\n",
-                  ntohl (hdr->num),
-                  ntohs (message->size));
-    }
+  if (ntohl (hdr->num) % 5 == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got message %u of size %u\n",
+                ntohl (hdr->num), ntohs (message->size));
+  }
 #endif
   n++;
-  set_bit(ntohl(hdr->num));
+  set_bit (ntohl (hdr->num));
   if (0 == (n % (TOTAL_MSGS / 100)))
-    {
-      fprintf (stderr, ".");
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly,
-                                               NULL);
-    }
+  {
+    fprintf (stderr, ".");
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+  }
   if (n == TOTAL_MSGS)
     end ();
 }
@@ -442,63 +433,62 @@ notify_ready (void *cls, size_t size, void *buf)
   th_p2 = NULL;
 
   if (buf == NULL)
-    {
-      GNUNET_break (0);
-      ok = 42;
-      return 0;
-    }
+  {
+    GNUNET_break (0);
+    ok = 42;
+    return 0;
+  }
   ret = 0;
   s = get_size (n);
   GNUNET_assert (size >= s);
   GNUNET_assert (buf != NULL);
   cbuf = buf;
   do
-    {
-      hdr.header.size = htons (s);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (n);
-      msg_sent = n;
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
-      ret += s - sizeof (struct TestMessage);
+  {
+    hdr.header.size = htons (s);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (n);
+    msg_sent = n;
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
+    ret += s - sizeof (struct TestMessage);
 #if VERBOSE
-      if (n % 5000 == 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Sending message %u of size %u\n",
-                      n,
-                      s);
-        }
-#endif
-      n++;
-      s = get_size (n);
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
+    if (n % 5000 == 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending message %u of size %u\n", n, s);
     }
+#endif
+    n++;
+    s = get_size (n);
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= s);
   if (n < TOTAL_MSGS)
   {
     th_p2 = GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                            &p1.id,
-                                            s, 0, TIMEOUT,
-                                            &notify_ready,
-                                            NULL);
+                                                    &p1.id,
+                                                    s, 0, TIMEOUT,
+                                                    &notify_ready, NULL);
     msg_scheduled = n;
   }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "All messages scheduled to be sent!!\n");
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        GNUNET_SCHEDULER_cancel(die_task);
-      die_task = GNUNET_SCHEDULER_add_delayed (UNRELIABLE_TIMEOUT, &end_unreliably, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "All messages scheduled to be sent!!\n");
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    die_task =
+        GNUNET_SCHEDULER_add_delayed (UNRELIABLE_TIMEOUT, &end_unreliably,
+                                      NULL);
+  }
   if (n % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Returning total message block of size %u\n",
-                  ret);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Returning total message block of size %u\n", ret);
+  }
   total_bytes += ret;
   return ret;
 }
@@ -511,14 +501,13 @@ notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
   connected--;
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 #endif
   if (th_p2 != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
-      th_p2 = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th_p2);
+    th_p2 = NULL;
+  }
 }
 
 
@@ -530,57 +519,57 @@ notify_connect (void *cls,
                 uint32_t ats_count)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n", 
-              GNUNET_i2s (peer), 
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
   if (cls == &p1)
+  {
+    GNUNET_TRANSPORT_set_quota (p1.th,
+                                &p2.id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+    start_time = GNUNET_TIME_absolute_get ();
+    connected++;
+  }
+  else
+  {
+    GNUNET_TRANSPORT_set_quota (p2.th,
+                                &p1.id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+    connected++;
+  }
+  if (2 == connected)
+  {
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
     {
-      GNUNET_TRANSPORT_set_quota (p1.th,
-                                  &p2.id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-      start_time = GNUNET_TIME_absolute_get ();
-      connected++;
+      GNUNET_SCHEDULER_cancel (die_task);
     }
-  else
+    if (GNUNET_SCHEDULER_NO_TASK != tct)
     {
-      GNUNET_TRANSPORT_set_quota (p2.th,
-                                  &p1.id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-      connected++;
+      GNUNET_SCHEDULER_cancel (tct);
+      tct = GNUNET_SCHEDULER_NO_TASK;
     }
-  if (2 == connected)
+    if (p2_hello_canceled == GNUNET_NO)
     {
-      if (GNUNET_SCHEDULER_NO_TASK != die_task)
-        {
-          GNUNET_SCHEDULER_cancel (die_task);     
-        }
-      if (GNUNET_SCHEDULER_NO_TASK != tct)
-        {
-          GNUNET_SCHEDULER_cancel (tct);
-          tct = GNUNET_SCHEDULER_NO_TASK;
-        }
-      if (p2_hello_canceled == GNUNET_NO)
-        {
-          GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
-          p2_hello_canceled = GNUNET_YES;
-        }
-      if (p1_hello_canceled == GNUNET_NO)
-        {
-          GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
-          p1_hello_canceled = GNUNET_YES;
-        }
-
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly, NULL);
-      GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
-                                              &p1.id,
-                                              get_size (0), 0, TIMEOUT,
-                                              &notify_ready,
-                                              NULL);
-      
+      GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
+      p2_hello_canceled = GNUNET_YES;
     }
+    if (p1_hello_canceled == GNUNET_NO)
+    {
+      GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
+      p1_hello_canceled = GNUNET_YES;
+    }
+
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+    GNUNET_TRANSPORT_notify_transmit_ready (p2.th,
+                                            &p1.id,
+                                            get_size (0), 0, TIMEOUT,
+                                            &notify_ready, NULL);
+
+  }
 }
 
 
@@ -591,31 +580,31 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME"))
-    {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONFIGURATION_get_value_string (p->cfg,
-                                                            "PATHS", "SERVICEHOME", 
-                                                            &p->servicehome));
-      GNUNET_DISK_directory_remove (p->servicehome);
-    }
+  if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+  {
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_string (p->cfg,
+                                                          "PATHS",
+                                                          "SERVICEHOME",
+                                                          &p->servicehome));
+    GNUNET_DISK_directory_remove (p->servicehome);
+  }
 
 
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL,
-                                        "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE_ARM
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
 
   p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL,
                                     p,
                                     &notify_receive,
-                                    &notify_connect,
-                                    &notify_disconnect);
+                                    &notify_connect, &notify_disconnect);
   GNUNET_assert (p->th != NULL);
 }
 
@@ -637,32 +626,32 @@ get_path_from_PATH (char *binary)
 
   p = getenv ("PATH");
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("PATH environment variable is unset.\n"));
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("PATH environment variable is unset.\n"));
+    return NULL;
+  }
   path = GNUNET_strdup (p);     /* because we write on it */
   buf = GNUNET_malloc (strlen (path) + 20);
   pos = path;
 
   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, binary);
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          GNUNET_free (path);
-          return buf;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, binary);
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    *end = '\0';
+    sprintf (buf, "%s/%s", pos, binary);
+    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
     {
       GNUNET_free (path);
       return buf;
     }
+    pos = end + 1;
+  }
+  sprintf (buf, "%s/%s", pos, binary);
+  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    GNUNET_free (path);
+    return buf;
+  }
   GNUNET_free (buf);
   GNUNET_free (path);
   return NULL;
@@ -679,16 +668,18 @@ get_path_from_PATH (char *binary)
  *         can be run properly, GNUNET_NO otherwise
  */
 static int
-check_gnunet_nat_binary(char *binary)
+check_gnunet_nat_binary (char *binary)
 {
   struct stat statbuf;
   char *p;
+
 #ifdef MINGW
   SOCKET rawsock;
 #endif
 
 #ifdef MINGW
   char *binaryexe;
+
   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
   p = get_path_from_PATH (binaryexe);
   free (binaryexe);
@@ -696,36 +687,34 @@ check_gnunet_nat_binary(char *binary)
   p = get_path_from_PATH (binary);
 #endif
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not find binary `%s' in PATH!\n"),
-                  binary);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not find binary `%s' in PATH!\n"), binary);
+    return GNUNET_NO;
+  }
   if (0 != STAT (p, &statbuf))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("stat (%s) failed: %s\n"),
-                  p,
-                  STRERROR (errno));
-      GNUNET_free (p);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("stat (%s) failed: %s\n"), p, STRERROR (errno));
+    GNUNET_free (p);
+    return GNUNET_SYSERR;
+  }
   GNUNET_free (p);
 #ifndef MINGW
-  if ( (0 != (statbuf.st_mode & S_ISUID)) &&
-       (statbuf.st_uid == 0) )
+  if ((0 != (statbuf.st_mode & S_ISUID)) && (statbuf.st_uid == 0))
     return GNUNET_YES;
   return GNUNET_NO;
 #else
   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == rawsock)
-    {
-      DWORD err = GetLastError ();
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n", err);
-      return GNUNET_NO; /* not running as administrator */
-    }
+  {
+    DWORD err = GetLastError ();
+
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n",
+                err);
+    return GNUNET_NO;           /* not running as administrator */
+  }
   closesocket (rawsock);
   return GNUNET_YES;
 #endif
@@ -733,18 +722,13 @@ check_gnunet_nat_binary(char *binary)
 
 
 static void
-try_connect (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  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);
+  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);
+                                      &try_connect, NULL);
 }
 
 
@@ -754,48 +738,46 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly,
-                                           NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
   if (is_tcp)
-    {
-      setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
+    setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
+  }
   else if (is_http)
-    {
-      setup_peer (&p1, "test_transport_api_rel_http_peer1.conf");
-      setup_peer (&p2, "test_transport_api_rel_http_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_rel_http_peer1.conf");
+    setup_peer (&p2, "test_transport_api_rel_http_peer2.conf");
+  }
   else if (is_https)
-    {
-      setup_peer (&p1, "test_transport_api_rel_https_peer1.conf");
-      setup_peer (&p2, "test_transport_api_rel_https_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_rel_https_peer1.conf");
+    setup_peer (&p2, "test_transport_api_rel_https_peer2.conf");
+  }
   else if (is_udp)
-    {
-      setup_peer (&p1, "test_transport_api_udp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_udp_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_udp_peer1.conf");
+    setup_peer (&p2, "test_transport_api_udp_peer2.conf");
+  }
   else if (is_unix)
-    {
-      setup_peer (&p1, "test_transport_api_unix_peer1.conf");
-      setup_peer (&p2, "test_transport_api_unix_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_unix_peer1.conf");
+    setup_peer (&p2, "test_transport_api_unix_peer2.conf");
+  }
   else if (is_tcp_nat)
-    {
-      setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
-      setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
+    setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
+  }
   else if (is_wlan)
-    {
-      setup_peer (&p1, "test_transport_api_wlan_peer1.conf");
-      setup_peer (&p2, "test_transport_api_wlan_peer2.conf");
-    }
+  {
+    setup_peer (&p1, "test_transport_api_wlan_peer1.conf");
+    setup_peer (&p2, "test_transport_api_wlan_peer2.conf");
+  }
   else
     GNUNET_assert (0);
-  GNUNET_assert(p1.th != NULL);
-  GNUNET_assert(p2.th != NULL);
+  GNUNET_assert (p1.th != NULL);
+  GNUNET_assert (p2.th != NULL);
   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
   p1_hello_canceled = GNUNET_NO;
   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
@@ -820,15 +802,17 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
 
-  if ((GNUNET_YES == is_tcp_nat) && (check_gnunet_nat_binary("gnunet-nat-server") != GNUNET_YES))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Not running NAT test case, binaries not properly installed.\n");
-      return 0;
-    }
+  if ((GNUNET_YES == is_tcp_nat) &&
+      (check_gnunet_nat_binary ("gnunet-nat-server") != GNUNET_YES))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Not running NAT test case, binaries not properly installed.\n");
+    return 0;
+  }
 
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-transport-api-unreliability", "nohelp",
@@ -839,53 +823,66 @@ check ()
   if (is_https)
   {
     struct stat sbuf;
-    if (0 == stat (cert_file_p1, &sbuf ))
+
+    if (0 == stat (cert_file_p1, &sbuf))
     {
-      if (0 == remove(cert_file_p1))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed existing certificate file `%s'\n",cert_file_p1);
+      if (0 == remove (cert_file_p1))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed existing certificate file `%s'\n",
+                    cert_file_p1);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",cert_file_p1);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",
+                    cert_file_p1);
     }
 
-    if (0 == stat (key_file_p1, &sbuf ))
+    if (0 == stat (key_file_p1, &sbuf))
     {
-      if (0 == remove(key_file_p1))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed private key file `%s'\n",key_file_p1);
+      if (0 == remove (key_file_p1))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed private key file `%s'\n",
+                    key_file_p1);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to private key file `%s'\n",key_file_p1);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Failed to private key file `%s'\n", key_file_p1);
     }
 
-    if (0 == stat (cert_file_p2, &sbuf ))
+    if (0 == stat (cert_file_p2, &sbuf))
     {
-      if (0 == remove(cert_file_p2))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed existing certificate file `%s'\n",cert_file_p2);
+      if (0 == remove (cert_file_p2))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed existing certificate file `%s'\n",
+                    cert_file_p2);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",cert_file_p2);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to remove certfile `%s'\n",
+                    cert_file_p2);
     }
 
-    if (0 == stat (key_file_p2, &sbuf ))
+    if (0 == stat (key_file_p2, &sbuf))
     {
-      if (0 == remove(key_file_p2))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Successfully removed private key file `%s'\n",key_file_p2);
+      if (0 == remove (key_file_p2))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Successfully removed private key file `%s'\n",
+                    key_file_p2);
       else
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to private key file `%s'\n",key_file_p2);
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Failed to private key file `%s'\n", key_file_p2);
     }
-    GNUNET_free(key_file_p1);
-    GNUNET_free(key_file_p2);
-    GNUNET_free(cert_file_p1);
-    GNUNET_free(cert_file_p2);
+    GNUNET_free (key_file_p1);
+    GNUNET_free (key_file_p2);
+    GNUNET_free (cert_file_p1);
+    GNUNET_free (cert_file_p2);
   }
 
-  if (p1.servicehome != NULL) 
-    {
-      GNUNET_DISK_directory_remove (p1.servicehome);
-      GNUNET_free(p1.servicehome);
-    }
+  if (p1.servicehome != NULL)
+  {
+    GNUNET_DISK_directory_remove (p1.servicehome);
+    GNUNET_free (p1.servicehome);
+  }
   if (p2.servicehome != NULL)
-    {
-      GNUNET_DISK_directory_remove (p2.servicehome); 
-      GNUNET_free(p2.servicehome);
-    }
+  {
+    GNUNET_DISK_directory_remove (p2.servicehome);
+    GNUNET_free (p2.servicehome);
+  }
   return ok;
 }
 
@@ -900,40 +897,40 @@ main (int argc, char *argv[])
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-2");
 
-  if (strstr(argv[0], "tcp_nat") != NULL)
-    {
-      is_tcp_nat = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "tcp_nat");
-    }
-  else if (strstr(argv[0], "tcp") != NULL)
-    {
-      is_tcp = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "tcp");
-    }
-  else if (strstr(argv[0], "https") != NULL)
-    {
-      is_https = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "https");
-    }
-  else if (strstr(argv[0], "http") != NULL)
-    {
-      is_http = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "http");
-    }
-  else if (strstr(argv[0], "udp") != NULL)
-    {
-      is_udp = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "udp");
-    }
-  else if (strstr(argv[0], "unix") != NULL)
-    {
-      is_unix = GNUNET_YES;
-      GNUNET_asprintf(&test_name, "unix");
-    }
-  else if (strstr(argv[0], "wlan") != NULL)
-    {
-       is_wlan = GNUNET_YES;
-    }
+  if (strstr (argv[0], "tcp_nat") != NULL)
+  {
+    is_tcp_nat = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "tcp_nat");
+  }
+  else if (strstr (argv[0], "tcp") != NULL)
+  {
+    is_tcp = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "tcp");
+  }
+  else if (strstr (argv[0], "https") != NULL)
+  {
+    is_https = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "https");
+  }
+  else if (strstr (argv[0], "http") != NULL)
+  {
+    is_http = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "http");
+  }
+  else if (strstr (argv[0], "udp") != NULL)
+  {
+    is_udp = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "udp");
+  }
+  else if (strstr (argv[0], "unix") != NULL)
+  {
+    is_unix = GNUNET_YES;
+    GNUNET_asprintf (&test_name, "unix");
+  }
+  else if (strstr (argv[0], "wlan") != NULL)
+  {
+    is_wlan = GNUNET_YES;
+  }
   GNUNET_log_setup ("test-transport-api-unreliability",
 #if VERBOSE
                     "DEBUG",
@@ -943,7 +940,7 @@ main (int argc, char *argv[])
                     NULL);
   ret = check ();
 
-  GNUNET_free_non_null(test_name);
+  GNUNET_free_non_null (test_name);
   return ret;
 }