uncrustify as demanded.

4 files changed, 298 insertions, 302 deletions

diff --git a/src/block/bg_bf.c b/src/block/bg_bf.c
index 20aa59bbc..9814a28ec 100644
--- a/src/block/bg_bf.c
+++ b/src/block/bg_bf.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file block/bg_bf.c
  * @brief implementation of a block group using a Bloom filter
@@ -32,8 +32,7 @@
 /**
  * Internal data structure for a block group.
  */
-struct BfGroupInternals
-{
+struct BfGroupInternals {
   /**
    * A Bloom filter to weed out duplicate replies probabilistically.
    */
@@ -48,7 +47,6 @@ struct BfGroupInternals
    * Size of @a bf.
    */
   uint32_t bf_size;
-
 };
 
 
@@ -63,24 +61,24 @@ struct BfGroupInternals
  *         supported, #GNUNET_SYSERR on error
  */
 static int
-bf_group_serialize_cb (struct GNUNET_BLOCK_Group *bg,
-                       uint32_t *nonce,
-                       void **raw_data,
-                       size_t *raw_data_size)
+bf_group_serialize_cb(struct GNUNET_BLOCK_Group *bg,
+                      uint32_t *nonce,
+                      void **raw_data,
+                      size_t *raw_data_size)
 {
   struct BfGroupInternals *gi = bg->internal_cls;
   char *raw;
 
-  raw = GNUNET_malloc (gi->bf_size);
+  raw = GNUNET_malloc(gi->bf_size);
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_bloomfilter_get_raw_data (gi->bf,
-                                                 raw,
-                                                 gi->bf_size))
-  {
-    GNUNET_free (raw);
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_CONTAINER_bloomfilter_get_raw_data(gi->bf,
+                                                raw,
+                                                gi->bf_size))
+    {
+      GNUNET_free(raw);
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   *nonce = gi->bf_mutator;
   *raw_data = raw;
   *raw_data_size = gi->bf_size;
@@ -97,22 +95,22 @@ bf_group_serialize_cb (struct GNUNET_BLOCK_Group *bg,
  * @param seen_results_count number of entries in @a seen_results
  */
 static void
-bf_group_mark_seen_cb (struct GNUNET_BLOCK_Group *bg,
-                       const struct GNUNET_HashCode *seen_results,
-                       unsigned int seen_results_count)
+bf_group_mark_seen_cb(struct GNUNET_BLOCK_Group *bg,
+                      const struct GNUNET_HashCode *seen_results,
+                      unsigned int seen_results_count)
 {
   struct BfGroupInternals *gi = bg->internal_cls;
 
-  for (unsigned int i=0;i<seen_results_count;i++)
-  {
-    struct GNUNET_HashCode mhash;
+  for (unsigned int i = 0; i < seen_results_count; i++)
+    {
+      struct GNUNET_HashCode mhash;
 
-    GNUNET_BLOCK_mingle_hash (&seen_results[i],
-                              gi->bf_mutator,
-                              &mhash);
-    GNUNET_CONTAINER_bloomfilter_add (gi->bf,
-                                      &mhash);
-  }
+      GNUNET_BLOCK_mingle_hash(&seen_results[i],
+                               gi->bf_mutator,
+                               &mhash);
+      GNUNET_CONTAINER_bloomfilter_add(gi->bf,
+                                       &mhash);
+    }
 }
 
 
@@ -126,8 +124,8 @@ bf_group_mark_seen_cb (struct GNUNET_BLOCK_Group *bg,
  *         we failed.
  */
 static int
-bf_group_merge_cb (struct GNUNET_BLOCK_Group *bg1,
-                   const struct GNUNET_BLOCK_Group *bg2)
+bf_group_merge_cb(struct GNUNET_BLOCK_Group *bg1,
+                  const struct GNUNET_BLOCK_Group *bg2)
 {
   struct BfGroupInternals *gi1 = bg1->internal_cls;
   struct BfGroupInternals *gi2 = bg2->internal_cls;
@@ -136,8 +134,8 @@ bf_group_merge_cb (struct GNUNET_BLOCK_Group *bg1,
     return GNUNET_NO;
   if (gi1->bf_size != gi2->bf_size)
     return GNUNET_NO;
-  GNUNET_CONTAINER_bloomfilter_or2 (gi1->bf,
-                                    gi2->bf);
+  GNUNET_CONTAINER_bloomfilter_or2(gi1->bf,
+                                   gi2->bf);
   return GNUNET_OK;
 }
 
@@ -148,13 +146,13 @@ bf_group_merge_cb (struct GNUNET_BLOCK_Group *bg1,
  * @param bg group to destroy, NULL is allowed
  */
 static void
-bf_group_destroy_cb (struct GNUNET_BLOCK_Group *bg)
+bf_group_destroy_cb(struct GNUNET_BLOCK_Group *bg)
 {
   struct BfGroupInternals *gi = bg->internal_cls;
 
-  GNUNET_CONTAINER_bloomfilter_free (gi->bf);
-  GNUNET_free (gi);
-  GNUNET_free (bg);
+  GNUNET_CONTAINER_bloomfilter_free(gi->bf);
+  GNUNET_free(gi);
+  GNUNET_free(bg);
 }
 
 
@@ -172,24 +170,24 @@ bf_group_destroy_cb (struct GNUNET_BLOCK_Group *bg)
  *         by this @a type of block (this is not an error)
  */
 struct GNUNET_BLOCK_Group *
-GNUNET_BLOCK_GROUP_bf_create (void *cls,
-                              size_t bf_size,
-                              unsigned int bf_k,
-                              enum GNUNET_BLOCK_Type type,
-                              uint32_t nonce,
-                              const void *raw_data,
-                              size_t raw_data_size)
+GNUNET_BLOCK_GROUP_bf_create(void *cls,
+                             size_t bf_size,
+                             unsigned int bf_k,
+                             enum GNUNET_BLOCK_Type type,
+                             uint32_t nonce,
+                             const void *raw_data,
+                             size_t raw_data_size)
 {
   struct BfGroupInternals *gi;
   struct GNUNET_BLOCK_Group *bg;
 
-  gi = GNUNET_new (struct BfGroupInternals);
-  gi->bf = GNUNET_CONTAINER_bloomfilter_init ((bf_size != raw_data_size) ? NULL : raw_data,
-                                              bf_size,
-                                              bf_k);
+  gi = GNUNET_new(struct BfGroupInternals);
+  gi->bf = GNUNET_CONTAINER_bloomfilter_init((bf_size != raw_data_size) ? NULL : raw_data,
+                                             bf_size,
+                                             bf_k);
   gi->bf_mutator = nonce;
   gi->bf_size = bf_size;
-  bg = GNUNET_new (struct GNUNET_BLOCK_Group);
+  bg = GNUNET_new(struct GNUNET_BLOCK_Group);
   bg->type = type;
   bg->serialize_cb = &bf_group_serialize_cb;
   bg->mark_seen_cb = &bf_group_mark_seen_cb;
@@ -211,8 +209,8 @@ GNUNET_BLOCK_GROUP_bf_create (void *cls,
  *         #GNUNET_NO if @a hc was definitively not in @bg (but now is)
  */
 int
-GNUNET_BLOCK_GROUP_bf_test_and_set (struct GNUNET_BLOCK_Group *bg,
-                                    const struct GNUNET_HashCode *hc)
+GNUNET_BLOCK_GROUP_bf_test_and_set(struct GNUNET_BLOCK_Group *bg,
+                                   const struct GNUNET_HashCode *hc)
 {
   struct BfGroupInternals *gi;
   struct GNUNET_HashCode mhash;
@@ -220,15 +218,15 @@ GNUNET_BLOCK_GROUP_bf_test_and_set (struct GNUNET_BLOCK_Group *bg,
   if (NULL == bg)
     return GNUNET_NO;
   gi = bg->internal_cls;
-  GNUNET_BLOCK_mingle_hash (hc,
-                            gi->bf_mutator,
-                            &mhash);
+  GNUNET_BLOCK_mingle_hash(hc,
+                           gi->bf_mutator,
+                           &mhash);
   if (GNUNET_YES ==
-      GNUNET_CONTAINER_bloomfilter_test (gi->bf,
-                                         &mhash))
+      GNUNET_CONTAINER_bloomfilter_test(gi->bf,
+                                        &mhash))
     return GNUNET_YES;
-  GNUNET_CONTAINER_bloomfilter_add (gi->bf,
-                                    &mhash);
+  GNUNET_CONTAINER_bloomfilter_add(gi->bf,
+                                   &mhash);
   return GNUNET_NO;
 }
 
@@ -247,8 +245,8 @@ GNUNET_BLOCK_GROUP_bf_test_and_set (struct GNUNET_BLOCK_Group *bg,
  * @return must be a power of two and smaller or equal to 2^15.
  */
 size_t
-GNUNET_BLOCK_GROUP_compute_bloomfilter_size (unsigned int entry_count,
-                                             unsigned int k)
+GNUNET_BLOCK_GROUP_compute_bloomfilter_size(unsigned int entry_count,
+                                            unsigned int k)
 {
   size_t size;
   unsigned int ideal = (entry_count * k) / 4;
diff --git a/src/block/block.c b/src/block/block.c
index ecc98f88d..78e9bc2dd 100644
--- a/src/block/block.c
+++ b/src/block/block.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file block/block.c
@@ -34,8 +34,7 @@
 /**
  * Handle for a plugin.
  */
-struct Plugin
-{
+struct Plugin {
   /**
    * Name of the shared library.
    */
@@ -51,8 +50,7 @@ struct Plugin
 /**
  * Handle to an initialized block library.
  */
-struct GNUNET_BLOCK_Context
-{
+struct GNUNET_BLOCK_Context {
   /**
    * Array of our plugins.
    */
@@ -78,18 +76,18 @@ struct GNUNET_BLOCK_Context
  * @param hc where to store the result.
  */
 void
-GNUNET_BLOCK_mingle_hash (const struct GNUNET_HashCode *in,
-                          uint32_t mingle_number,
-                          struct GNUNET_HashCode *hc)
+GNUNET_BLOCK_mingle_hash(const struct GNUNET_HashCode *in,
+                         uint32_t mingle_number,
+                         struct GNUNET_HashCode *hc)
 {
   struct GNUNET_HashCode m;
 
-  GNUNET_CRYPTO_hash (&mingle_number,
-                      sizeof (uint32_t),
-                      &m);
-  GNUNET_CRYPTO_hash_xor (&m,
-                          in,
-                          hc);
+  GNUNET_CRYPTO_hash(&mingle_number,
+                     sizeof(uint32_t),
+                     &m);
+  GNUNET_CRYPTO_hash_xor(&m,
+                         in,
+                         hc);
 }
 
 
@@ -101,23 +99,23 @@ GNUNET_BLOCK_mingle_hash (const struct GNUNET_HashCode *in,
  * @param lib_ret the plugin API
  */
 static void
-add_plugin (void *cls,
-            const char *library_name,
-            void *lib_ret)
+add_plugin(void *cls,
+           const char *library_name,
+           void *lib_ret)
 {
   struct GNUNET_BLOCK_Context *ctx = cls;
   struct GNUNET_BLOCK_PluginFunctions *api = lib_ret;
   struct Plugin *plugin;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Loading block plugin `%s'\n",
-              library_name);
-  plugin = GNUNET_new (struct Plugin);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Loading block plugin `%s'\n",
+             library_name);
+  plugin = GNUNET_new(struct Plugin);
   plugin->api = api;
-  plugin->library_name = GNUNET_strdup (library_name);
-  GNUNET_array_append (ctx->plugins,
-                       ctx->num_plugins,
-                       plugin);
+  plugin->library_name = GNUNET_strdup(library_name);
+  GNUNET_array_append(ctx->plugins,
+                      ctx->num_plugins,
+                      plugin);
 }
 
 
@@ -129,16 +127,16 @@ add_plugin (void *cls,
  * @return NULL on error
  */
 struct GNUNET_BLOCK_Context *
-GNUNET_BLOCK_context_create (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_BLOCK_context_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_BLOCK_Context *ctx;
 
-  ctx = GNUNET_new (struct GNUNET_BLOCK_Context);
+  ctx = GNUNET_new(struct GNUNET_BLOCK_Context);
   ctx->cfg = cfg;
-  GNUNET_PLUGIN_load_all ("libgnunet_plugin_block_",
-                          (void *) cfg,
-                          &add_plugin,
-                          ctx);
+  GNUNET_PLUGIN_load_all("libgnunet_plugin_block_",
+                         (void *)cfg,
+                         &add_plugin,
+                         ctx);
   return ctx;
 }
 
@@ -149,21 +147,21 @@ GNUNET_BLOCK_context_create (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param ctx context to destroy
  */
 void
-GNUNET_BLOCK_context_destroy (struct GNUNET_BLOCK_Context *ctx)
+GNUNET_BLOCK_context_destroy(struct GNUNET_BLOCK_Context *ctx)
 {
   struct Plugin *plugin;
 
   for (unsigned int i = 0; i < ctx->num_plugins; i++)
-  {
-    plugin = ctx->plugins[i];
-    GNUNET_break (NULL ==
-                  GNUNET_PLUGIN_unload (plugin->library_name,
+    {
+      plugin = ctx->plugins[i];
+      GNUNET_break(NULL ==
+                   GNUNET_PLUGIN_unload(plugin->library_name,
                                         plugin->api));
-    GNUNET_free (plugin->library_name);
-    GNUNET_free (plugin);
-  }
-  GNUNET_free (ctx->plugins);
-  GNUNET_free (ctx);
+      GNUNET_free(plugin->library_name);
+      GNUNET_free(plugin);
+    }
+  GNUNET_free(ctx->plugins);
+  GNUNET_free(ctx);
 }
 
 
@@ -178,10 +176,10 @@ GNUNET_BLOCK_context_destroy (struct GNUNET_BLOCK_Context *ctx)
  *         supported, #GNUNET_SYSERR on error
  */
 int
-GNUNET_BLOCK_group_serialize (struct GNUNET_BLOCK_Group *bg,
-                              uint32_t *nonce,
-                              void **raw_data,
-                              size_t *raw_data_size)
+GNUNET_BLOCK_group_serialize(struct GNUNET_BLOCK_Group *bg,
+                             uint32_t *nonce,
+                             void **raw_data,
+                             size_t *raw_data_size)
 {
   *nonce = 0;
   *raw_data = NULL;
@@ -190,10 +188,10 @@ GNUNET_BLOCK_group_serialize (struct GNUNET_BLOCK_Group *bg,
     return GNUNET_NO;
   if (NULL == bg->serialize_cb)
     return GNUNET_NO;
-  return bg->serialize_cb (bg,
-                           nonce,
-                           raw_data,
-                           raw_data_size);
+  return bg->serialize_cb(bg,
+                          nonce,
+                          raw_data,
+                          raw_data_size);
 }
 
 
@@ -203,11 +201,11 @@ GNUNET_BLOCK_group_serialize (struct GNUNET_BLOCK_Group *bg,
  * @param bg group to destroy, NULL is allowed
  */
 void
-GNUNET_BLOCK_group_destroy (struct GNUNET_BLOCK_Group *bg)
+GNUNET_BLOCK_group_destroy(struct GNUNET_BLOCK_Group *bg)
 {
   if (NULL == bg)
     return;
-  bg->destroy_cb (bg);
+  bg->destroy_cb(bg);
 }
 
 
@@ -224,24 +222,24 @@ GNUNET_BLOCK_group_destroy (struct GNUNET_BLOCK_Group *bg)
  *         #GNUNET_SYSERR if merging is not supported
  */
 int
-GNUNET_BLOCK_group_merge (struct GNUNET_BLOCK_Group *bg1,
-                          struct GNUNET_BLOCK_Group *bg2)
+GNUNET_BLOCK_group_merge(struct GNUNET_BLOCK_Group *bg1,
+                         struct GNUNET_BLOCK_Group *bg2)
 {
   int ret;
 
   if (NULL == bg2)
     return GNUNET_OK;
   if (NULL == bg1)
-  {
-    bg2->destroy_cb (bg2);
-    return GNUNET_OK;
-  }
+    {
+      bg2->destroy_cb(bg2);
+      return GNUNET_OK;
+    }
   if (NULL == bg1->merge_cb)
     return GNUNET_SYSERR;
-  GNUNET_assert (bg1->merge_cb == bg1->merge_cb);
-  ret = bg1->merge_cb (bg1,
-                       bg2);
-  bg2->destroy_cb (bg2);
+  GNUNET_assert(bg1->merge_cb == bg1->merge_cb);
+  ret = bg1->merge_cb(bg1,
+                      bg2);
+  bg2->destroy_cb(bg2);
   return ret;
 }
 
@@ -254,23 +252,23 @@ GNUNET_BLOCK_group_merge (struct GNUNET_BLOCK_Group *bg1,
  * @return NULL if no matching plugin exists
  */
 static struct GNUNET_BLOCK_PluginFunctions *
-find_plugin (struct GNUNET_BLOCK_Context *ctx,
-             enum GNUNET_BLOCK_Type type)
+find_plugin(struct GNUNET_BLOCK_Context *ctx,
+            enum GNUNET_BLOCK_Type type)
 {
   struct Plugin *plugin;
   unsigned int j;
 
   for (unsigned i = 0; i < ctx->num_plugins; i++)
-  {
-    plugin = ctx->plugins[i];
-    j = 0;
-    while (0 != (plugin->api->types[j]))
     {
-      if (type == plugin->api->types[j])
-        return plugin->api;
-      j++;
+      plugin = ctx->plugins[i];
+      j = 0;
+      while (0 != (plugin->api->types[j]))
+        {
+          if (type == plugin->api->types[j])
+            return plugin->api;
+          j++;
+        }
     }
-  }
   return NULL;
 }
 
@@ -287,32 +285,32 @@ find_plugin (struct GNUNET_BLOCK_Context *ctx,
  *         by this @a type of block (this is not an error)
  */
 struct GNUNET_BLOCK_Group *
-GNUNET_BLOCK_group_create (struct GNUNET_BLOCK_Context *ctx,
-                           enum GNUNET_BLOCK_Type type,
-                           uint32_t nonce,
-                           const void *raw_data,
-                           size_t raw_data_size,
-                           ...)
+GNUNET_BLOCK_group_create(struct GNUNET_BLOCK_Context *ctx,
+                          enum GNUNET_BLOCK_Type type,
+                          uint32_t nonce,
+                          const void *raw_data,
+                          size_t raw_data_size,
+                          ...)
 {
   struct GNUNET_BLOCK_PluginFunctions *plugin;
   struct GNUNET_BLOCK_Group *bg;
   va_list ap;
 
-  plugin = find_plugin (ctx,
-                        type);
+  plugin = find_plugin(ctx,
+                       type);
   if (NULL == plugin)
     return NULL;
   if (NULL == plugin->create_group)
     return NULL;
-  va_start (ap,
-            raw_data_size);
-  bg = plugin->create_group (plugin->cls,
-                             type,
-                             nonce,
-                             raw_data,
-                             raw_data_size,
-                             ap);
-  va_end (ap);
+  va_start(ap,
+           raw_data_size);
+  bg = plugin->create_group(plugin->cls,
+                            type,
+                            nonce,
+                            raw_data,
+                            raw_data_size,
+                            ap);
+  va_end(ap);
   return bg;
 }
 
@@ -336,31 +334,31 @@ GNUNET_BLOCK_group_create (struct GNUNET_BLOCK_Context *ctx,
  * @return characterization of result
  */
 enum GNUNET_BLOCK_EvaluationResult
-GNUNET_BLOCK_evaluate (struct GNUNET_BLOCK_Context *ctx,
-                       enum GNUNET_BLOCK_Type type,
-                       struct GNUNET_BLOCK_Group *group,
-                       enum GNUNET_BLOCK_EvaluationOptions eo,
-                       const struct GNUNET_HashCode *query,
-                       const void *xquery,
-                       size_t xquery_size,
-                       const void *reply_block,
-                       size_t reply_block_size)
+GNUNET_BLOCK_evaluate(struct GNUNET_BLOCK_Context *ctx,
+                      enum GNUNET_BLOCK_Type type,
+                      struct GNUNET_BLOCK_Group *group,
+                      enum GNUNET_BLOCK_EvaluationOptions eo,
+                      const struct GNUNET_HashCode *query,
+                      const void *xquery,
+                      size_t xquery_size,
+                      const void *reply_block,
+                      size_t reply_block_size)
 {
-  struct GNUNET_BLOCK_PluginFunctions *plugin = find_plugin (ctx,
-                                                             type);
+  struct GNUNET_BLOCK_PluginFunctions *plugin = find_plugin(ctx,
+                                                            type);
 
   if (NULL == plugin)
     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
-  return plugin->evaluate (plugin->cls,
-                           ctx,
-                           type,
-                           group,
-                           eo,
-                           query,
-                           xquery,
-                           xquery_size,
-                           reply_block,
-                           reply_block_size);
+  return plugin->evaluate(plugin->cls,
+                          ctx,
+                          type,
+                          group,
+                          eo,
+                          query,
+                          xquery,
+                          xquery_size,
+                          reply_block,
+                          reply_block_size);
 }
 
 
@@ -376,22 +374,22 @@ GNUNET_BLOCK_evaluate (struct GNUNET_BLOCK_Context *ctx,
  *         (or if extracting a key from a block of this type does not work)
  */
 int
-GNUNET_BLOCK_get_key (struct GNUNET_BLOCK_Context *ctx,
-                      enum GNUNET_BLOCK_Type type,
-                      const void *block,
-                      size_t block_size,
-                      struct GNUNET_HashCode *key)
+GNUNET_BLOCK_get_key(struct GNUNET_BLOCK_Context *ctx,
+                     enum GNUNET_BLOCK_Type type,
+                     const void *block,
+                     size_t block_size,
+                     struct GNUNET_HashCode *key)
 {
-  struct GNUNET_BLOCK_PluginFunctions *plugin = find_plugin (ctx,
-                                                             type);
+  struct GNUNET_BLOCK_PluginFunctions *plugin = find_plugin(ctx,
+                                                            type);
 
   if (plugin == NULL)
     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
-  return plugin->get_key (plugin->cls,
-                          type,
-                          block,
-                          block_size,
-                          key);
+  return plugin->get_key(plugin->cls,
+                         type,
+                         block,
+                         block_size,
+                         key);
 }
 
 
@@ -407,17 +405,17 @@ GNUNET_BLOCK_get_key (struct GNUNET_BLOCK_Context *ctx,
  * @return #GNUNET_SYSERR if not supported, #GNUNET_OK on success
  */
 int
-GNUNET_BLOCK_group_set_seen (struct GNUNET_BLOCK_Group *bg,
-                             const struct GNUNET_HashCode *seen_results,
-                             unsigned int seen_results_count)
+GNUNET_BLOCK_group_set_seen(struct GNUNET_BLOCK_Group *bg,
+                            const struct GNUNET_HashCode *seen_results,
+                            unsigned int seen_results_count)
 {
   if (NULL == bg)
     return GNUNET_OK;
   if (NULL == bg->mark_seen_cb)
     return GNUNET_SYSERR;
-  bg->mark_seen_cb (bg,
-                    seen_results,
-                    seen_results_count);
+  bg->mark_seen_cb(bg,
+                   seen_results,
+                   seen_results_count);
   return GNUNET_OK;
 }
 
diff --git a/src/block/plugin_block_template.c b/src/block/plugin_block_template.c
index 1918f00aa..5bfacb660 100644
--- a/src/block/plugin_block_template.c
+++ b/src/block/plugin_block_template.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file block/plugin_block_template.c
@@ -56,37 +56,37 @@
  *         by this @a type of block (this is not an error)
  */
 static struct GNUNET_BLOCK_Group *
-block_plugin_template_create_group (void *cls,
-                                    enum GNUNET_BLOCK_Type type,
-                                    uint32_t nonce,
-                                    const void *raw_data,
-                                    size_t raw_data_size,
-                                    va_list va)
+block_plugin_template_create_group(void *cls,
+                                   enum GNUNET_BLOCK_Type type,
+                                   uint32_t nonce,
+                                   const void *raw_data,
+                                   size_t raw_data_size,
+                                   va_list va)
 {
   unsigned int bf_size;
   const char *guard;
 
-  guard = va_arg (va, const char *);
-  if (0 == strcmp (guard,
-                   "seen-set-size"))
-    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned int),
-                                                           BLOOMFILTER_K);
-  else if (0 == strcmp (guard,
-                        "filter-size"))
-    bf_size = va_arg (va, unsigned int);
+  guard = va_arg(va, const char *);
+  if (0 == strcmp(guard,
+                  "seen-set-size"))
+    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size(va_arg(va, unsigned int),
+                                                          BLOOMFILTER_K);
+  else if (0 == strcmp(guard,
+                       "filter-size"))
+    bf_size = va_arg(va, unsigned int);
   else
-  {
-    GNUNET_break (0);
-    bf_size = TEMPLATE_BF_SIZE;
-  }
-  GNUNET_break (NULL == va_arg (va, const char *));
-  return GNUNET_BLOCK_GROUP_bf_create (cls,
-                                       bf_size,
-                                       BLOOMFILTER_K,
-                                       type,
-                                       nonce,
-                                       raw_data,
-                                       raw_data_size);
+    {
+      GNUNET_break(0);
+      bf_size = TEMPLATE_BF_SIZE;
+    }
+  GNUNET_break(NULL == va_arg(va, const char *));
+  return GNUNET_BLOCK_GROUP_bf_create(cls,
+                                      bf_size,
+                                      BLOOMFILTER_K,
+                                      type,
+                                      nonce,
+                                      raw_data,
+                                      raw_data_size);
 }
 
 
@@ -107,27 +107,27 @@ block_plugin_template_create_group (void *cls,
  * @return characterization of result
  */
 static enum GNUNET_BLOCK_EvaluationResult
-block_plugin_template_evaluate (void *cls,
-                                struct GNUNET_BLOCK_Context *ctx,
-                                enum GNUNET_BLOCK_Type type,
-                                struct GNUNET_BLOCK_Group *group,
-                                enum GNUNET_BLOCK_EvaluationOptions eo,
-                                const struct GNUNET_HashCode *query,
-                                const void *xquery,
-                                size_t xquery_size,
-                                const void *reply_block,
-                                size_t reply_block_size)
+block_plugin_template_evaluate(void *cls,
+                               struct GNUNET_BLOCK_Context *ctx,
+                               enum GNUNET_BLOCK_Type type,
+                               struct GNUNET_BLOCK_Group *group,
+                               enum GNUNET_BLOCK_EvaluationOptions eo,
+                               const struct GNUNET_HashCode *query,
+                               const void *xquery,
+                               size_t xquery_size,
+                               const void *reply_block,
+                               size_t reply_block_size)
 {
   struct GNUNET_HashCode chash;
 
   if (NULL == reply_block)
     return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-  GNUNET_CRYPTO_hash (reply_block,
-                      reply_block_size,
-                      &chash);
+  GNUNET_CRYPTO_hash(reply_block,
+                     reply_block_size,
+                     &chash);
   if (GNUNET_YES ==
-      GNUNET_BLOCK_GROUP_bf_test_and_set (group,
-                                          &chash))
+      GNUNET_BLOCK_GROUP_bf_test_and_set(group,
+                                         &chash))
     return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
   return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
 }
@@ -145,11 +145,11 @@ block_plugin_template_evaluate (void *cls,
  *         (or if extracting a key from a block of this type does not work)
  */
 static int
-block_plugin_template_get_key (void *cls,
-                               enum GNUNET_BLOCK_Type type,
-                               const void *block,
-                               size_t block_size,
-                               struct GNUNET_HashCode *key)
+block_plugin_template_get_key(void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              const void *block,
+                              size_t block_size,
+                              struct GNUNET_HashCode *key)
 {
   return GNUNET_SYSERR;
 }
@@ -161,7 +161,7 @@ block_plugin_template_get_key (void *cls,
  * @param cls a `const struct GNUNET_CONFIGURATION_Handle`
  */
 void *
-libgnunet_plugin_block_template_init (void *cls)
+libgnunet_plugin_block_template_init(void *cls)
 {
   static enum GNUNET_BLOCK_Type types[] =
   {
@@ -170,7 +170,7 @@ libgnunet_plugin_block_template_init (void *cls)
   };
   struct GNUNET_BLOCK_PluginFunctions *api;
 
-  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions);
   api->evaluate = &block_plugin_template_evaluate;
   api->get_key = &block_plugin_template_get_key;
   api->create_group = &block_plugin_template_create_group;
@@ -183,11 +183,11 @@ libgnunet_plugin_block_template_init (void *cls)
  * Exit point from the plugin.
  */
 void *
-libgnunet_plugin_block_template_done (void *cls)
+libgnunet_plugin_block_template_done(void *cls)
 {
   struct GNUNET_BLOCK_PluginFunctions *api = cls;
 
-  GNUNET_free (api);
+  GNUNET_free(api);
   return NULL;
 }
 
diff --git a/src/block/plugin_block_test.c b/src/block/plugin_block_test.c
index 4543847aa..815fc15cc 100644
--- a/src/block/plugin_block_test.c
+++ b/src/block/plugin_block_test.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file block/plugin_block_test.c
@@ -54,37 +54,37 @@
  *         by this @a type of block (this is not an error)
  */
 static struct GNUNET_BLOCK_Group *
-block_plugin_test_create_group (void *cls,
-                                enum GNUNET_BLOCK_Type type,
-                                uint32_t nonce,
-                                const void *raw_data,
-                                size_t raw_data_size,
-                                va_list va)
+block_plugin_test_create_group(void *cls,
+                               enum GNUNET_BLOCK_Type type,
+                               uint32_t nonce,
+                               const void *raw_data,
+                               size_t raw_data_size,
+                               va_list va)
 {
   unsigned int bf_size;
   const char *guard;
 
-  guard = va_arg (va, const char *);
-  if (0 == strcmp (guard,
-                   "seen-set-size"))
-    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned int),
-                                                           BLOOMFILTER_K);
-  else if (0 == strcmp (guard,
-                        "filter-size"))
-    bf_size = va_arg (va, unsigned int);
+  guard = va_arg(va, const char *);
+  if (0 == strcmp(guard,
+                  "seen-set-size"))
+    bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size(va_arg(va, unsigned int),
+                                                          BLOOMFILTER_K);
+  else if (0 == strcmp(guard,
+                       "filter-size"))
+    bf_size = va_arg(va, unsigned int);
   else
-  {
-    GNUNET_break (0);
-    bf_size = TEST_BF_SIZE;
-  }
-  GNUNET_break (NULL == va_arg (va, const char *));
-  return GNUNET_BLOCK_GROUP_bf_create (cls,
-                                       bf_size,
-                                       BLOOMFILTER_K,
-                                       type,
-                                       nonce,
-                                       raw_data,
-                                       raw_data_size);
+    {
+      GNUNET_break(0);
+      bf_size = TEST_BF_SIZE;
+    }
+  GNUNET_break(NULL == va_arg(va, const char *));
+  return GNUNET_BLOCK_GROUP_bf_create(cls,
+                                      bf_size,
+                                      BLOOMFILTER_K,
+                                      type,
+                                      nonce,
+                                      raw_data,
+                                      raw_data_size);
 }
 
 
@@ -105,37 +105,37 @@ block_plugin_test_create_group (void *cls,
  * @return characterization of result
  */
 static enum GNUNET_BLOCK_EvaluationResult
-block_plugin_test_evaluate (void *cls,
-                            struct GNUNET_BLOCK_Context *ctx,
-                            enum GNUNET_BLOCK_Type type,
-                            struct GNUNET_BLOCK_Group *group,
-                            enum GNUNET_BLOCK_EvaluationOptions eo,
-                            const struct GNUNET_HashCode *query,
-                            const void *xquery,
-                            size_t xquery_size,
-                            const void *reply_block,
-                            size_t reply_block_size)
+block_plugin_test_evaluate(void *cls,
+                           struct GNUNET_BLOCK_Context *ctx,
+                           enum GNUNET_BLOCK_Type type,
+                           struct GNUNET_BLOCK_Group *group,
+                           enum GNUNET_BLOCK_EvaluationOptions eo,
+                           const struct GNUNET_HashCode *query,
+                           const void *xquery,
+                           size_t xquery_size,
+                           const void *reply_block,
+                           size_t reply_block_size)
 {
   struct GNUNET_HashCode chash;
 
-  if ( GNUNET_BLOCK_TYPE_TEST != type)
-  {
-    GNUNET_break (0);
-    return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
-  }
+  if (GNUNET_BLOCK_TYPE_TEST != type)
+    {
+      GNUNET_break(0);
+      return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
+    }
   if (0 != xquery_size)
-  {
-    GNUNET_break_op (0);
-    return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-  }
+    {
+      GNUNET_break_op(0);
+      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
+    }
   if (NULL == reply_block)
     return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-  GNUNET_CRYPTO_hash (reply_block,
-                      reply_block_size,
-                      &chash);
+  GNUNET_CRYPTO_hash(reply_block,
+                     reply_block_size,
+                     &chash);
   if (GNUNET_YES ==
-      GNUNET_BLOCK_GROUP_bf_test_and_set (group,
-                                          &chash))
+      GNUNET_BLOCK_GROUP_bf_test_and_set(group,
+                                         &chash))
     return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
   return GNUNET_BLOCK_EVALUATION_OK_MORE;
 }
@@ -153,11 +153,11 @@ block_plugin_test_evaluate (void *cls,
  *         (or if extracting a key from a block of this type does not work)
  */
 static int
-block_plugin_test_get_key (void *cls,
-                           enum GNUNET_BLOCK_Type type,
-                           const void *block,
-                           size_t block_size,
-                           struct GNUNET_HashCode *key)
+block_plugin_test_get_key(void *cls,
+                          enum GNUNET_BLOCK_Type type,
+                          const void *block,
+                          size_t block_size,
+                          struct GNUNET_HashCode *key)
 {
   /* always fails since there is no fixed relationship between
    * keys and values for test values */
@@ -172,7 +172,7 @@ block_plugin_test_get_key (void *cls,
  * @return the exported block API
  */
 void *
-libgnunet_plugin_block_test_init (void *cls)
+libgnunet_plugin_block_test_init(void *cls)
 {
   static enum GNUNET_BLOCK_Type types[] =
   {
@@ -181,7 +181,7 @@ libgnunet_plugin_block_test_init (void *cls)
   };
   struct GNUNET_BLOCK_PluginFunctions *api;
 
-  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions);
   api->evaluate = &block_plugin_test_evaluate;
   api->get_key = &block_plugin_test_get_key;
   api->create_group = &block_plugin_test_create_group;
@@ -197,11 +197,11 @@ libgnunet_plugin_block_test_init (void *cls)
  * @return NULL
  */
 void *
-libgnunet_plugin_block_test_done (void *cls)
+libgnunet_plugin_block_test_done(void *cls)
 {
   struct GNUNET_BLOCK_PluginFunctions *api = cls;
 
-  GNUNET_free (api);
+  GNUNET_free(api);
   return NULL;
 }