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

8 files changed, 195 insertions, 127 deletions

diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index ac472d166..9b2b50f01 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -164,7 +164,6 @@ enum GNUNET_GenericReturnValue
  * Endian operations
  */
 
-#if __BYTE_ORDER == __LITTLE_ENDIAN
 #if defined(bswap_16) || defined(bswap_32) || defined(bswap_64)
 #define BYTE_SWAP_16(x) bswap_16 (x)
 #define BYTE_SWAP_32(x) bswap_32 (x)
@@ -184,6 +183,7 @@ enum GNUNET_GenericReturnValue
                                              56))
 #endif
 
+#if __BYTE_ORDER == __LITTLE_ENDIAN
 #define GNUNET_htobe16(x) BYTE_SWAP_16 (x)
 #define GNUNET_htole16(x) (x)
 #define GNUNET_be16toh(x) BYTE_SWAP_16 (x)
diff --git a/src/include/gnunet_mysql_compat.h b/src/include/gnunet_mysql_compat.h
index bb1e8de8a..9fb9db30f 100644
--- a/src/include/gnunet_mysql_compat.h
+++ b/src/include/gnunet_mysql_compat.h
@@ -42,13 +42,13 @@ extern "C"
 #endif
 
 #ifndef LIBMARIADB
-#if MYSQL_VERSION_ID < 80000
-#define MYSQL_BOOL bool;
+#if MYSQL_VERSION_ID >= 80000
+#define MYSQL_BOOL bool
 #else
-#define MYSQL_BOOL my_bool; //MySQL < 8 wants this
+#define MYSQL_BOOL my_bool /* MySQL < 8 wants this */
 #endif
 #else
-#define MYSQL_BOOL my_bool //MariaDB still uses my_bool
+#define MYSQL_BOOL my_bool /* MariaDB still uses my_bool */
 #endif
 
 #if 0                           /* keep Emacsens' auto-indent happy */
diff --git a/src/pq/pq.h b/src/pq/pq.h
index 85cfcc070..f9b59e058 100644
--- a/src/pq/pq.h
+++ b/src/pq/pq.h
@@ -90,6 +90,11 @@ struct GNUNET_PQ_Context
   struct GNUNET_NETWORK_Handle *rfd;
 
   /**
+   * How fast should we resubscribe again?
+   */
+  struct GNUNET_TIME_Relative resubscribe_backoff;
+
+  /**
    * Flags controlling the connection.
    */
   enum GNUNET_PQ_Options flags;
diff --git a/src/pq/pq_event.c b/src/pq/pq_event.c
index b0ed6798a..6dbacf7ff 100644
--- a/src/pq/pq_event.c
+++ b/src/pq/pq_event.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet
-   Copyright (C) 2021 GNUnet e.V.
+   Copyright (C) 2021, 2023 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -283,11 +283,17 @@ do_scheduler_notify (void *cls)
               "Resubscribing\n");
   if (NULL == db->rfd)
   {
+    db->resubscribe_backoff
+      = GNUNET_TIME_relative_max (db->resubscribe_backoff,
+                                  GNUNET_TIME_UNIT_SECONDS);
+    db->resubscribe_backoff
+      = GNUNET_TIME_STD_BACKOFF (db->resubscribe_backoff);
     db->event_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                    &do_scheduler_notify,
                                                    db);
     return;
   }
+  db->resubscribe_backoff = GNUNET_TIME_UNIT_SECONDS;
   db->event_task
     = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                      db->rfd,
@@ -387,7 +393,7 @@ manage_subscribe (struct GNUNET_PQ_Context *db,
  * @param value the event handler
  * @return #GNUNET_OK to continue to iterate
  */
-static int
+static enum GNUNET_GenericReturnValue
 register_notify (void *cls,
                  const struct GNUNET_ShortHashCode *sh,
                  void *value)
diff --git a/src/rest/gnunet-rest-server.c b/src/rest/gnunet-rest-server.c
index 1ea4471d1..f9a949e61 100644
--- a/src/rest/gnunet-rest-server.c
+++ b/src/rest/gnunet-rest-server.c
@@ -132,7 +132,7 @@ static char *basic_auth_secret;
 /**
  * User of the service
  */
-char cuser[LOGIN_NAME_MAX];
+char cuser[_POSIX_LOGIN_NAME_MAX];
 
 /**
  * Allowed Origins (CORS)
@@ -1207,7 +1207,7 @@ run (void *cls,
         GNUNET_SCHEDULER_shutdown ();
         return;
       }
-      if (0 != getlogin_r (cuser, LOGIN_NAME_MAX))
+      if (0 != getlogin_r (cuser, _POSIX_LOGIN_NAME_MAX))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     "Unable to get user.\n");
diff --git a/src/testing/testing_api_loop.c b/src/testing/testing_api_loop.c
index 5385a53d7..7d719afc0 100644
--- a/src/testing/testing_api_loop.c
+++ b/src/testing/testing_api_loop.c
@@ -25,7 +25,6 @@
  * @author Marcello Stanisci (GNU Taler testing)
  * @author t3sserakt
  */
-#include "gnunet_common.h"
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_testing_ng_lib.h"
@@ -520,6 +519,7 @@ GNUNET_TESTING_run (const struct GNUNET_TESTING_Command *commands,
   return is;
 }
 
+
 struct GNUNET_TESTING_Command
 GNUNET_TESTING_command_new (void *cls,
                             const char *label,
@@ -543,6 +543,7 @@ GNUNET_TESTING_command_new (void *cls,
 
 }
 
+
 /**
  * Closure for #loop_run().
  */
@@ -603,6 +604,7 @@ loop_run (void *cls)
                       mp);
 }
 
+
 /**
  * Continuation function from GNUNET_HELPER_send()
  *
@@ -617,6 +619,7 @@ clear_msg (void *cls, int result)
   GNUNET_assert (GNUNET_YES == result);
 }
 
+
 /**
  * Adding a helper handle to the interpreter.
  *
@@ -632,7 +635,7 @@ GNUNET_TESTING_add_netjail_helper (struct GNUNET_TESTING_Interpreter *is,
 
 
 /**
- * Send Message to netjail nodes. 
+ * Send Message to netjail nodes.
  *
  * @param is The interpreter.
  * @param global_node_number The netjail node to inform.
@@ -640,8 +643,8 @@ GNUNET_TESTING_add_netjail_helper (struct GNUNET_TESTING_Interpreter *is,
  */
 void
 send_message_to_netjail (struct GNUNET_TESTING_Interpreter *is,
-                                        unsigned int global_node_number,
-                                        struct GNUNET_MessageHeader *header)
+                         unsigned int global_node_number,
+                         struct GNUNET_MessageHeader *header)
 {
   const struct GNUNET_HELPER_Handle *helper;
 
@@ -657,10 +660,11 @@ send_message_to_netjail (struct GNUNET_TESTING_Interpreter *is,
     NULL);
 }
 
+
 void
 TST_interpreter_send_barrier_crossable (struct GNUNET_TESTING_Interpreter *is,
-                                      const char *barrier_name,
-                                      unsigned int global_node_number)
+                                        const char *barrier_name,
+                                        unsigned int global_node_number)
 {
   struct CommandBarrierCrossable *adm;
   size_t msg_length;
@@ -677,13 +681,12 @@ TST_interpreter_send_barrier_crossable (struct GNUNET_TESTING_Interpreter *is,
   adm->header.size = htons ((uint16_t) msg_length);
   memcpy (&adm[1], barrier_name, name_len);
   send_message_to_netjail (is,
-                                          global_node_number,
-                                          &adm->header);
+                           global_node_number,
+                           &adm->header);
   GNUNET_free (adm);
 }
 
 
-
 int
 free_barrier_node_cb (void *cls,
                       const struct GNUNET_ShortHashCode *key,
@@ -699,12 +702,13 @@ free_barrier_node_cb (void *cls,
   if (GNUNET_NO == is->finishing)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "TST_interpreter_send_barrier_crossable\n");
+                "TST_interpreter_send_barrier_crossable\n");
     TST_interpreter_send_barrier_crossable (is,
-                                          barrier->name,
-                                          node->node_number);
+                                            barrier->name,
+                                            node->node_number);
   }
-  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (barrier->nodes, key, node));
+  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (
+                   barrier->nodes, key, node));
   return GNUNET_YES;
 }
 
@@ -718,7 +722,7 @@ free_barrier_node_cb (void *cls,
   */
 struct GNUNET_TESTING_Barrier *
 TST_interpreter_get_barrier (struct GNUNET_TESTING_Interpreter *is,
-                            const char *barrier_name)
+                             const char *barrier_name)
 {
   struct GNUNET_HashCode hc;
   struct GNUNET_ShortHashCode create_key;
@@ -745,7 +749,7 @@ TST_interpreter_finish_attached_cmds (struct GNUNET_TESTING_Interpreter *is,
   struct CommandListEntry *pos;
   struct FreeBarrierNodeCbCls *free_barrier_node_cb_cls;
   struct GNUNET_TESTING_Barrier *barrier = TST_interpreter_get_barrier (is,
-                                                                       barrier_name);
+                                                                        barrier_name);
 
   while (NULL != barrier && NULL != (pos = barrier->cmds_head))
   {
@@ -756,8 +760,8 @@ TST_interpreter_finish_attached_cmds (struct GNUNET_TESTING_Interpreter *is,
         GNUNET_NO == pos->command->asynchronous_finish)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "command label %s finish\n",
-                pos->command->label);
+                  "command label %s finish\n",
+                  pos->command->label);
       GNUNET_TESTING_async_finish (pos->command->ac);
     }
     else if (GNUNET_NO == pos->command->ac->finished)
@@ -781,7 +785,8 @@ TST_interpreter_finish_attached_cmds (struct GNUNET_TESTING_Interpreter *is,
     free_barrier_node_cb_cls->is = is;
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "freeing nodes\n");
-    GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes, free_barrier_node_cb,
+    GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes,
+                                            free_barrier_node_cb,
                                             free_barrier_node_cb_cls);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "nodes freed\n");
@@ -807,7 +812,8 @@ free_barriers_cb (void *cls,
     free_barrier_node_cb_cls = GNUNET_new (struct FreeBarrierNodeCbCls);
     free_barrier_node_cb_cls->barrier = barrier;
     free_barrier_node_cb_cls->is = is;
-    GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes, free_barrier_node_cb,
+    GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes,
+                                            free_barrier_node_cb,
                                             free_barrier_node_cb_cls);
     GNUNET_CONTAINER_multishortmap_destroy (barrier->nodes);
     barrier->nodes = NULL;
@@ -824,6 +830,7 @@ free_barriers_cb (void *cls,
   return GNUNET_YES;
 }
 
+
 /**
   * Deleting all barriers create in the context of this interpreter.
   *
@@ -847,7 +854,7 @@ TST_interpreter_delete_barriers (struct GNUNET_TESTING_Interpreter *is)
  */
 void
 TST_interpreter_add_barrier (struct GNUNET_TESTING_Interpreter *is,
-                                        struct GNUNET_TESTING_Barrier *barrier)
+                             struct GNUNET_TESTING_Barrier *barrier)
 {
   struct GNUNET_HashCode hc;
   struct GNUNET_ShortHashCode create_key;
diff --git a/src/util/bio.c b/src/util/bio.c
index 70620aea7..7e3aa0d16 100644
--- a/src/util/bio.c
+++ b/src/util/bio.c
@@ -182,8 +182,9 @@ GNUNET_BIO_read_close (struct GNUNET_BIO_ReadHandle *h, char **emsg)
   return err;
 }
 
+
 void
-GNUNET_BIO_read_set_error (struct GNUNET_BIO_ReadHandle *h, const char* emsg)
+GNUNET_BIO_read_set_error (struct GNUNET_BIO_ReadHandle *h, const char*emsg)
 {
   GNUNET_assert (NULL == h->emsg);
   h->emsg = GNUNET_strdup (emsg);
@@ -380,7 +381,6 @@ GNUNET_BIO_read_string (struct GNUNET_BIO_ReadHandle *h,
 }
 
 
-
 /**
  * Read a float.
  *
@@ -510,13 +510,12 @@ GNUNET_BIO_write_open_file (const char *fn)
   struct GNUNET_DISK_FileHandle *fd;
   struct GNUNET_BIO_WriteHandle *h;
 
-  fd =
-    GNUNET_DISK_file_open (fn,
-                           GNUNET_DISK_OPEN_WRITE
-                           | GNUNET_DISK_OPEN_TRUNCATE
-                           | GNUNET_DISK_OPEN_CREATE,
-                           GNUNET_DISK_PERM_USER_READ
-                           | GNUNET_DISK_PERM_USER_WRITE);
+  fd = GNUNET_DISK_file_open (fn,
+                              GNUNET_DISK_OPEN_WRITE
+                              | GNUNET_DISK_OPEN_TRUNCATE
+                              | GNUNET_DISK_OPEN_CREATE,
+                              GNUNET_DISK_PERM_USER_READ
+                              | GNUNET_DISK_PERM_USER_WRITE);
   if (NULL == fd)
     return NULL;
   h = GNUNET_malloc (sizeof(struct GNUNET_BIO_WriteHandle) + BIO_BUFFER_SIZE);
@@ -553,8 +552,9 @@ GNUNET_BIO_write_open_buffer (void)
  *        if the handle has an error message, the return value is #GNUNET_SYSERR
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
-GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h, char **emsg)
+enum GNUNET_GenericReturnValue
+GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h,
+                        char **emsg)
 {
   int err;
 
@@ -567,7 +567,10 @@ GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h, char **emsg)
   {
   case IO_FILE:
     if (NULL == h->fd)
-      return GNUNET_SYSERR;
+    {
+      err = GNUNET_SYSERR;
+      break;
+    }
     if (GNUNET_OK != GNUNET_BIO_flush (h))
     {
       if (NULL != emsg)
@@ -600,21 +603,23 @@ GNUNET_BIO_write_close (struct GNUNET_BIO_WriteHandle *h, char **emsg)
  * @return #GNUNET_OK upon success.  Upon failure #GNUNET_SYSERR is returned
  *         and the file is closed
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
 {
   ssize_t ret;
 
   if (IO_FILE != h->type)
     return GNUNET_OK;
-
-  ret = GNUNET_DISK_file_write (h->fd, h->buffer, h->have);
+  ret = GNUNET_DISK_file_write (h->fd,
+                                h->buffer,
+                                h->have);
   if (ret != (ssize_t) h->have)
   {
     GNUNET_DISK_file_close (h->fd);
     h->fd = NULL;
     GNUNET_free (h->emsg);
-    GNUNET_asprintf (&h->emsg, _ ("Unable to flush buffer to file"));
+    GNUNET_asprintf (&h->emsg,
+                     "Unable to flush buffer to file");
     return GNUNET_SYSERR;
   }
   h->have = 0;
@@ -634,7 +639,7 @@ GNUNET_BIO_flush (struct GNUNET_BIO_WriteHandle *h)
  * @param size where to store the size of @e contents
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-int
+enum GNUNET_GenericReturnValue
 GNUNET_BIO_get_buffer_contents (struct GNUNET_BIO_WriteHandle *h,
                                 char **emsg,
                                 void **contents,
@@ -644,7 +649,10 @@ GNUNET_BIO_get_buffer_contents (struct GNUNET_BIO_WriteHandle *h,
     return GNUNET_SYSERR;
   if ((NULL == contents) || (NULL == size))
     return GNUNET_SYSERR;
-  int ret = (NULL != h->emsg) ? GNUNET_SYSERR : GNUNET_OK;
+  enum GNUNET_GenericReturnValue ret
+    = (NULL != h->emsg)
+    ? GNUNET_SYSERR
+    : GNUNET_OK;
   if (NULL != emsg)
     *emsg = h->emsg;
   else
@@ -663,7 +671,7 @@ GNUNET_BIO_get_buffer_contents (struct GNUNET_BIO_WriteHandle *h,
  * @param len the number of bytes to write
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
-static int
+static enum GNUNET_GenericReturnValue
 write_to_file (struct GNUNET_BIO_WriteHandle *h,
                const char *what,
                const char *source,
@@ -793,7 +801,6 @@ GNUNET_BIO_write_string (struct GNUNET_BIO_WriteHandle *h,
 }
 
 
-
 /**
  * Write a float.
  *
diff --git a/src/util/test_bio.c b/src/util/test_bio.c
index 90f0121d4..b407eccfe 100644
--- a/src/util/test_bio.c
+++ b/src/util/test_bio.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2009 GNUnet e.V.
+     Copyright (C) 2009, 2023 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
@@ -17,15 +17,11 @@
 
      SPDX-License-Identifier: AGPL3.0-or-later
  */
-
 /**
  * @file util/test_bio.c
  * @brief testcase for the buffered IO module
  * @author Ji Lu
  */
-
-
-
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #define TESTSTRING "testString"
@@ -43,53 +39,74 @@ test_normal_rw (void)
   char *rString = NULL;
   int64_t wNum = TESTNUMBER64;
   int64_t rNum = 0;
-
   struct GNUNET_BIO_WriteSpec ws[] = {
-    GNUNET_BIO_write_spec_string ("test-normal-rw-string", TESTSTRING),
-    GNUNET_BIO_write_spec_int64 ("test-normal-rw-int64", &wNum),
+    GNUNET_BIO_write_spec_string ("test-normal-rw-string",
+                                  TESTSTRING),
+    GNUNET_BIO_write_spec_int64 ("test-normal-rw-int64",
+                                 &wNum),
     GNUNET_BIO_write_spec_end (),
   };
-
   struct GNUNET_BIO_ReadSpec rs[] = {
-    GNUNET_BIO_read_spec_string ("test-normal-rw-string", &rString, 200),
-    GNUNET_BIO_read_spec_int64 ("test-normal-rw-int64", &rNum),
+    GNUNET_BIO_read_spec_string ("test-normal-rw-string",
+                                 &rString,
+                                 200),
+    GNUNET_BIO_read_spec_int64 ("test-normal-rw-int64",
+                                &rNum),
     GNUNET_BIO_read_spec_end (),
   };
 
   /* I/O on file */
   wh = GNUNET_BIO_write_open_file (filename);
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_spec_commit (wh, ws));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (wh, NULL));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_spec_commit (wh, ws));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_close (wh, NULL));
 
   rh = GNUNET_BIO_read_open_file (filename);
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_spec_commit (rh, rs));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
-  GNUNET_assert (0 == strcmp (TESTSTRING, rString));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_spec_commit (rh,
+                                              rs));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
+  GNUNET_assert (0 == strcmp (TESTSTRING,
+                              rString));
   GNUNET_assert (wNum == rNum);
-
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (filename));
+  GNUNET_free (rString);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_DISK_directory_remove (filename));
   GNUNET_free (filename);
 
   /* I/O on buffer */
   wh = GNUNET_BIO_write_open_buffer ();
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_spec_commit (wh, ws));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_spec_commit (wh,
+                                               ws));
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_BIO_get_buffer_contents (wh,
                                                  NULL,
                                                  &buffer,
                                                  &buffer_size));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (wh, NULL));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_close (wh,
+                                         NULL));
 
-  rh = GNUNET_BIO_read_open_buffer (buffer, buffer_size);
+  rh = GNUNET_BIO_read_open_buffer (buffer,
+                                    buffer_size);
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_spec_commit (rh, rs));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
-  GNUNET_assert (0 == strcmp (TESTSTRING, rString));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_spec_commit (rh,
+                                              rs));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
+  GNUNET_assert (0 == strcmp (TESTSTRING,
+                              rString));
   GNUNET_assert (wNum == rNum);
-
+  GNUNET_free (rString);
   GNUNET_free (buffer);
 
   return 0;
@@ -106,21 +123,26 @@ test_nullstring_rw (void)
 
   wh = GNUNET_BIO_write_open_file (filename);
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (wh,
-                                                       "test-nullstring-rw",
-                                                       NULL));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (wh, NULL));
-
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_string (wh,
+                                          "test-nullstring-rw",
+                                          NULL));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_close (wh,
+                                         NULL));
   rh = GNUNET_BIO_read_open_file (filename);
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (rh,
-                                                      "test-nullstring-rw",
-                                                      &rString, 200));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
-
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_string (rh,
+                                         "test-nullstring-rw",
+                                         &rString,
+                                         200));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
   GNUNET_assert (NULL == rString);
-
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (filename));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_DISK_directory_remove (filename));
   GNUNET_free (filename);
   return 0;
 }
@@ -136,21 +158,26 @@ test_emptystring_rw (void)
 
   wh = GNUNET_BIO_write_open_file (filename);
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (wh,
-                                                       "test-emptystring-rw",
-                                                       ""));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (wh, NULL));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_string (wh,
+                                          "test-emptystring-rw",
+                                          ""));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_close (wh,
+                                         NULL));
 
   rh = GNUNET_BIO_read_open_file (filename);
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (rh,
-                                                      "test-emptystring-rw",
-                                                      &rString, 200));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
-
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_string (rh,
+                                         "test-emptystring-rw",
+                                         &rString, 200));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
   GNUNET_free (rString);
-
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (filename));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_DISK_directory_remove (filename));
   GNUNET_free (filename);
   return 0;
 }
@@ -166,21 +193,25 @@ test_bigstring_rw (void)
 
   wh = GNUNET_BIO_write_open_file (filename);
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (wh,
-                                                       "test-bigstring-rw",
-                                                       TESTSTRING));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (wh, NULL));
-
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_string (wh,
+                                          "test-bigstring-rw",
+                                          TESTSTRING));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_close (wh,
+                                         NULL));
   rh = GNUNET_BIO_read_open_file (filename);
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (rh,
-                                                          "test-bigstring-rw",
-                                                          &rString, 1));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_close (rh, NULL));
-
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (rh,
+                                         "test-bigstring-rw",
+                                         &rString, 1));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
   GNUNET_assert (NULL == rString);
-
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (filename));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_DISK_directory_remove (filename));
   GNUNET_free (filename);
   return 0;
 }
@@ -195,11 +226,14 @@ test_directory_r (void)
 
   rh = GNUNET_BIO_read_open_file ("/dev");
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (rh,
-                                                   "test-directory-r",
-                                                   rString,
-                                                   sizeof (rString)));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_close (rh, NULL));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read (rh,
+                                  "test-directory-r",
+                                  rString,
+                                  sizeof (rString)));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
 #endif
   return 0;
 }
@@ -260,13 +294,17 @@ test_fullfile_rw (void)
 
   wh = GNUNET_BIO_write_open_file ("/dev/full");
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_spec_commit (wh, ws));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (wh, NULL));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_write_spec_commit (wh, ws));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_write_close (wh, NULL));
 
   rh = GNUNET_BIO_read_open_file ("/dev/null");
   GNUNET_assert (NULL != rh);
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_spec_commit (rh, rs));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_close (rh, NULL));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_spec_commit (rh, rs));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_close (rh, NULL));
 
   GNUNET_assert (NULL == rString);
 #endif
@@ -284,22 +322,27 @@ test_fakestring_rw (void)
 
   wh = GNUNET_BIO_write_open_file (filename);
   GNUNET_assert (NULL != wh);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (wh,
-                                                      "test-fakestring-rw-int32",
-                                                      2));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (wh, NULL));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_int32 (wh,
+                                         "test-fakestring-rw-int32",
+                                         2));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_write_close (wh,
+                                         NULL));
 
   rh = GNUNET_BIO_read_open_file (filename);
   GNUNET_assert (NULL != rh);
   GNUNET_assert (GNUNET_SYSERR ==
                  GNUNET_BIO_read_string (rh,
                                          "test-fakestring-rw-string",
-                                         &rString, 200));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_close (rh, NULL));
-
+                                         &rString,
+                                         200));
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_close (rh,
+                                        NULL));
   GNUNET_assert (NULL == rString);
-
-  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (filename));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_DISK_directory_remove (filename));
   GNUNET_free (filename);
   return 0;
 }