4 files changed, 297 insertions, 293 deletions

diff --git a/src/block/bg_bf.c b/src/block/bg_bf.c
index 9814a28ec..ae8ee0e51 100644
--- a/src/block/bg_bf.c
+++ b/src/block/bg_bf.c
@@ -32,7 +32,8 @@
 /**
  * Internal data structure for a block group.
  */
-struct BfGroupInternals {
+struct BfGroupInternals
+{
   /**
    * A Bloom filter to weed out duplicate replies probabilistically.
    */
@@ -61,24 +62,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;
@@ -95,22 +96,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;
-
-      GNUNET_BLOCK_mingle_hash(&seen_results[i],
-                               gi->bf_mutator,
-                               &mhash);
-      GNUNET_CONTAINER_bloomfilter_add(gi->bf,
-                                       &mhash);
-    }
+  {
+    struct GNUNET_HashCode mhash;
+
+    GNUNET_BLOCK_mingle_hash (&seen_results[i],
+                              gi->bf_mutator,
+                              &mhash);
+    GNUNET_CONTAINER_bloomfilter_add (gi->bf,
+                                      &mhash);
+  }
 }
 
 
@@ -124,8 +125,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;
@@ -134,8 +135,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;
 }
 
@@ -146,13 +147,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);
 }
 
 
@@ -170,24 +171,25 @@ 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;
@@ -209,8 +211,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;
@@ -218,15 +220,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;
 }
 
@@ -245,8 +247,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 78e9bc2dd..dafba9d8c 100644
--- a/src/block/block.c
+++ b/src/block/block.c
@@ -34,7 +34,8 @@
 /**
  * Handle for a plugin.
  */
-struct Plugin {
+struct Plugin
+{
   /**
    * Name of the shared library.
    */
@@ -50,7 +51,8 @@ struct Plugin {
 /**
  * Handle to an initialized block library.
  */
-struct GNUNET_BLOCK_Context {
+struct GNUNET_BLOCK_Context
+{
   /**
    * Array of our plugins.
    */
@@ -76,18 +78,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);
 }
 
 
@@ -99,23 +101,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);
 }
 
 
@@ -127,16 +129,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;
 }
 
@@ -147,21 +149,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);
 }
 
 
@@ -176,10 +178,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;
@@ -188,10 +190,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);
 }
 
 
@@ -201,11 +203,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);
 }
 
 
@@ -222,24 +224,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;
 }
 
@@ -252,23 +254,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]))
     {
-      plugin = ctx->plugins[i];
-      j = 0;
-      while (0 != (plugin->api->types[j]))
-        {
-          if (type == plugin->api->types[j])
-            return plugin->api;
-          j++;
-        }
+      if (type == plugin->api->types[j])
+        return plugin->api;
+      j++;
     }
+  }
   return NULL;
 }
 
@@ -285,32 +287,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;
 }
 
@@ -334,31 +336,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);
 }
 
 
@@ -374,22 +376,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);
 }
 
 
@@ -405,17 +407,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 5bfacb660..21b8a9be6 100644
--- a/src/block/plugin_block_template.c
+++ b/src/block/plugin_block_template.c
@@ -56,37 +56,38 @@
  *         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 +108,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 +146,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,16 +162,15 @@ 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[] =
-  {
+  static enum GNUNET_BLOCK_Type types[] = {
     /* FIXME: insert supported block types here */
     GNUNET_BLOCK_TYPE_ANY       /* end of list */
   };
   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 815fc15cc..b73e58cab 100644
--- a/src/block/plugin_block_test.c
+++ b/src/block/plugin_block_test.c
@@ -54,37 +54,38 @@
  *         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 +106,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;
-    }
+  {
+    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 +154,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,16 +173,15 @@ 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[] =
-  {
+  static enum GNUNET_BLOCK_Type types[] = {
     GNUNET_BLOCK_TYPE_TEST,
     GNUNET_BLOCK_TYPE_ANY       /* end of list */
   };
   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;
 }