1 files changed, 126 insertions, 124 deletions

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;
 }