uncrustify as demanded.

1 files changed, 286 insertions, 290 deletions

diff --git a/src/reclaim/reclaim_api.c b/src/reclaim/reclaim_api.c
index 725b2b876..a8790cd8e 100644
--- a/src/reclaim/reclaim_api.c
+++ b/src/reclaim/reclaim_api.c
@@ -16,7 +16,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    SPDX-License-Identifier: AGPL3.0-or-later
-   */
+ */
 
 /**
  * @file reclaim/reclaim_api.c
@@ -32,15 +32,13 @@
 #include "gnunet_reclaim_service.h"
 #include "reclaim.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "reclaim-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "reclaim-api", __VA_ARGS__)
 
 
 /**
  * Handle for an operation with the service.
  */
-struct GNUNET_RECLAIM_Operation
-{
-
+struct GNUNET_RECLAIM_Operation {
   /**
    * Main handle.
    */
@@ -102,9 +100,7 @@ struct GNUNET_RECLAIM_Operation
 /**
  * Handle for a ticket iterator operation
  */
-struct GNUNET_RECLAIM_TicketIterator
-{
-
+struct GNUNET_RECLAIM_TicketIterator {
   /**
    * Kept in a DLL.
    */
@@ -166,9 +162,7 @@ struct GNUNET_RECLAIM_TicketIterator
 /**
  * Handle for a attribute iterator operation
  */
-struct GNUNET_RECLAIM_AttributeIterator
-{
-
+struct GNUNET_RECLAIM_AttributeIterator {
   /**
    * Kept in a DLL.
    */
@@ -235,8 +229,7 @@ struct GNUNET_RECLAIM_AttributeIterator
 /**
  * Handle to the service.
  */
-struct GNUNET_RECLAIM_Handle
-{
+struct GNUNET_RECLAIM_Handle {
   /**
    * Configuration to use.
    */
@@ -320,7 +313,7 @@ struct GNUNET_RECLAIM_Handle
  * @param h handle to the reclaim service.
  */
 static void
-reconnect (struct GNUNET_RECLAIM_Handle *h);
+reconnect(struct GNUNET_RECLAIM_Handle *h);
 
 
 /**
@@ -329,12 +322,12 @@ reconnect (struct GNUNET_RECLAIM_Handle *h);
  * @param cls the handle
  */
 static void
-reconnect_task (void *cls)
+reconnect_task(void *cls)
 {
   struct GNUNET_RECLAIM_Handle *handle = cls;
 
   handle->reconnect_task = NULL;
-  reconnect (handle);
+  reconnect(handle);
 }
 
 
@@ -344,16 +337,16 @@ reconnect_task (void *cls)
  * @param handle our service
  */
 static void
-force_reconnect (struct GNUNET_RECLAIM_Handle *handle)
+force_reconnect(struct GNUNET_RECLAIM_Handle *handle)
 {
-  GNUNET_MQ_destroy (handle->mq);
+  GNUNET_MQ_destroy(handle->mq);
   handle->mq = NULL;
   handle->reconnect_backoff =
-    GNUNET_TIME_STD_BACKOFF (handle->reconnect_backoff);
+    GNUNET_TIME_STD_BACKOFF(handle->reconnect_backoff);
   handle->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed (handle->reconnect_backoff,
-                                  &reconnect_task,
-                                  handle);
+    GNUNET_SCHEDULER_add_delayed(handle->reconnect_backoff,
+                                 &reconnect_task,
+                                 handle);
 }
 
 
@@ -363,14 +356,14 @@ force_reconnect (struct GNUNET_RECLAIM_Handle *handle)
  * @param it entry to free
  */
 static void
-free_it (struct GNUNET_RECLAIM_AttributeIterator *it)
+free_it(struct GNUNET_RECLAIM_AttributeIterator *it)
 {
   struct GNUNET_RECLAIM_Handle *h = it->h;
 
-  GNUNET_CONTAINER_DLL_remove (h->it_head, h->it_tail, it);
+  GNUNET_CONTAINER_DLL_remove(h->it_head, h->it_tail, it);
   if (NULL != it->env)
-    GNUNET_MQ_discard (it->env);
-  GNUNET_free (it);
+    GNUNET_MQ_discard(it->env);
+  GNUNET_free(it);
 }
 
 /**
@@ -379,13 +372,13 @@ free_it (struct GNUNET_RECLAIM_AttributeIterator *it)
  * @param op the operation to free
  */
 static void
-free_op (struct GNUNET_RECLAIM_Operation *op)
+free_op(struct GNUNET_RECLAIM_Operation *op)
 {
   if (NULL == op)
     return;
   if (NULL != op->env)
-    GNUNET_MQ_discard (op->env);
-  GNUNET_free (op);
+    GNUNET_MQ_discard(op->env);
+  GNUNET_free(op);
 }
 
 
@@ -398,10 +391,11 @@ free_op (struct GNUNET_RECLAIM_Operation *op)
  * @param error error code
  */
 static void
-mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_RECLAIM_Handle *handle = cls;
-  force_reconnect (handle);
+
+  force_reconnect(handle);
 }
 
 
@@ -413,11 +407,11 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @param msg the message we received
  */
 static void
-handle_success_response (void *cls, const struct SuccessResultMessage *msg)
+handle_success_response(void *cls, const struct SuccessResultMessage *msg)
 {
   struct GNUNET_RECLAIM_Handle *h = cls;
   struct GNUNET_RECLAIM_Operation *op;
-  uint32_t r_id = ntohl (msg->id);
+  uint32_t r_id = ntohl(msg->id);
   int res;
   const char *emsg;
 
@@ -427,20 +421,20 @@ handle_success_response (void *cls, const struct SuccessResultMessage *msg)
   if (NULL == op)
     return;
 
-  res = ntohl (msg->op_result);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received SUCCESS_RESPONSE with result %d\n",
-       res);
+  res = ntohl(msg->op_result);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received SUCCESS_RESPONSE with result %d\n",
+      res);
 
   /* TODO: add actual error message to response... */
   if (GNUNET_SYSERR == res)
-    emsg = _ ("failed to store record\n");
+    emsg = _("failed to store record\n");
   else
     emsg = NULL;
   if (NULL != op->as_cb)
-    op->as_cb (op->cls, res, emsg);
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-  free_op (op);
+    op->as_cb(op->cls, res, emsg);
+  GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, op);
+  free_op(op);
 }
 
 
@@ -453,19 +447,19 @@ handle_success_response (void *cls, const struct SuccessResultMessage *msg)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-check_consume_ticket_result (void *cls,
-                             const struct ConsumeTicketResultMessage *msg)
+check_consume_ticket_result(void *cls,
+                            const struct ConsumeTicketResultMessage *msg)
 {
   size_t msg_len;
   size_t attrs_len;
 
-  msg_len = ntohs (msg->header.size);
-  attrs_len = ntohs (msg->attrs_len);
-  if (msg_len != sizeof (struct ConsumeTicketResultMessage) + attrs_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+  msg_len = ntohs(msg->header.size);
+  attrs_len = ntohs(msg->attrs_len);
+  if (msg_len != sizeof(struct ConsumeTicketResultMessage) + attrs_len)
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -478,16 +472,16 @@ check_consume_ticket_result (void *cls,
  * @param msg the message we received
  */
 static void
-handle_consume_ticket_result (void *cls,
-                              const struct ConsumeTicketResultMessage *msg)
+handle_consume_ticket_result(void *cls,
+                             const struct ConsumeTicketResultMessage *msg)
 {
   struct GNUNET_RECLAIM_Handle *h = cls;
   struct GNUNET_RECLAIM_Operation *op;
   size_t attrs_len;
-  uint32_t r_id = ntohl (msg->id);
+  uint32_t r_id = ntohl(msg->id);
 
-  attrs_len = ntohs (msg->attrs_len);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n");
+  attrs_len = ntohs(msg->attrs_len);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n");
 
 
   for (op = h->op_head; NULL != op; op = op->next)
@@ -500,28 +494,28 @@ handle_consume_ticket_result (void *cls,
     struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs;
     struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
     attrs =
-      GNUNET_RECLAIM_ATTRIBUTE_list_deserialize ((char *) &msg[1], attrs_len);
+      GNUNET_RECLAIM_ATTRIBUTE_list_deserialize((char *)&msg[1], attrs_len);
     if (NULL != op->ar_cb)
-    {
-      if (NULL == attrs)
       {
-        op->ar_cb (op->cls, &msg->identity, NULL);
+        if (NULL == attrs)
+          {
+            op->ar_cb(op->cls, &msg->identity, NULL);
+          }
+        else
+          {
+            for (le = attrs->list_head; NULL != le; le = le->next)
+              op->ar_cb(op->cls, &msg->identity, le->claim);
+            GNUNET_RECLAIM_ATTRIBUTE_list_destroy(attrs);
+            attrs = NULL;
+          }
+        op->ar_cb(op->cls, NULL, NULL);
       }
-      else
-      {
-        for (le = attrs->list_head; NULL != le; le = le->next)
-          op->ar_cb (op->cls, &msg->identity, le->claim);
-        GNUNET_RECLAIM_ATTRIBUTE_list_destroy (attrs);
-        attrs = NULL;
-      }
-      op->ar_cb (op->cls, NULL, NULL);
-    }
-    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-    free_op (op);
-    GNUNET_free_non_null (attrs);
+    GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, op);
+    free_op(op);
+    GNUNET_free_non_null(attrs);
     return;
   }
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
@@ -534,18 +528,18 @@ handle_consume_ticket_result (void *cls,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-check_attribute_result (void *cls, const struct AttributeResultMessage *msg)
+check_attribute_result(void *cls, const struct AttributeResultMessage *msg)
 {
   size_t msg_len;
   size_t attr_len;
 
-  msg_len = ntohs (msg->header.size);
-  attr_len = ntohs (msg->attr_len);
-  if (msg_len != sizeof (struct AttributeResultMessage) + attr_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+  msg_len = ntohs(msg->header.size);
+  attr_len = ntohs(msg->attr_len);
+  if (msg_len != sizeof(struct AttributeResultMessage) + attr_len)
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -558,17 +552,17 @@ check_attribute_result (void *cls, const struct AttributeResultMessage *msg)
  * @param msg the message we received
  */
 static void
-handle_attribute_result (void *cls, const struct AttributeResultMessage *msg)
+handle_attribute_result(void *cls, const struct AttributeResultMessage *msg)
 {
   static struct GNUNET_CRYPTO_EcdsaPrivateKey identity_dummy;
   struct GNUNET_RECLAIM_Handle *h = cls;
   struct GNUNET_RECLAIM_AttributeIterator *it;
   struct GNUNET_RECLAIM_Operation *op;
   size_t attr_len;
-  uint32_t r_id = ntohl (msg->id);
+  uint32_t r_id = ntohl(msg->id);
 
-  attr_len = ntohs (msg->attr_len);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n");
+  attr_len = ntohs(msg->attr_len);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n");
 
 
   for (it = h->it_head; NULL != it; it = it->next)
@@ -581,47 +575,47 @@ handle_attribute_result (void *cls, const struct AttributeResultMessage *msg)
     return;
 
   if ((0 ==
-       (memcmp (&msg->identity, &identity_dummy, sizeof (identity_dummy)))))
-  {
-    if ((NULL == it) && (NULL == op))
+       (memcmp(&msg->identity, &identity_dummy, sizeof(identity_dummy)))))
     {
-      GNUNET_break (0);
-      force_reconnect (h);
+      if ((NULL == it) && (NULL == op))
+        {
+          GNUNET_break(0);
+          force_reconnect(h);
+          return;
+        }
+      if (NULL != it)
+        {
+          if (NULL != it->finish_cb)
+            it->finish_cb(it->finish_cb_cls);
+          free_it(it);
+        }
+      if (NULL != op)
+        {
+          if (NULL != op->ar_cb)
+            op->ar_cb(op->cls, NULL, NULL);
+          GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, op);
+          free_op(op);
+        }
       return;
     }
-    if (NULL != it)
-    {
-      if (NULL != it->finish_cb)
-        it->finish_cb (it->finish_cb_cls);
-      free_it (it);
-    }
-    if (NULL != op)
-    {
-      if (NULL != op->ar_cb)
-        op->ar_cb (op->cls, NULL, NULL);
-      GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-      free_op (op);
-    }
-    return;
-  }
 
   {
     struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr;
-    attr = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &msg[1], attr_len);
+    attr = GNUNET_RECLAIM_ATTRIBUTE_deserialize((char *)&msg[1], attr_len);
     if (NULL != it)
-    {
-      if (NULL != it->proc)
-        it->proc (it->proc_cls, &msg->identity, attr);
-    }
+      {
+        if (NULL != it->proc)
+          it->proc(it->proc_cls, &msg->identity, attr);
+      }
     else if (NULL != op)
-    {
-      if (NULL != op->ar_cb)
-        op->ar_cb (op->cls, &msg->identity, attr);
-    }
-    GNUNET_free (attr);
+      {
+        if (NULL != op->ar_cb)
+          op->ar_cb(op->cls, &msg->identity, attr);
+      }
+    GNUNET_free(attr);
     return;
   }
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
@@ -633,13 +627,14 @@ handle_attribute_result (void *cls, const struct AttributeResultMessage *msg)
  * @param msg the message we received
  */
 static void
-handle_ticket_result (void *cls, const struct TicketResultMessage *msg)
+handle_ticket_result(void *cls, const struct TicketResultMessage *msg)
 {
   struct GNUNET_RECLAIM_Handle *handle = cls;
   struct GNUNET_RECLAIM_Operation *op;
   struct GNUNET_RECLAIM_TicketIterator *it;
-  uint32_t r_id = ntohl (msg->id);
+  uint32_t r_id = ntohl(msg->id);
   static const struct GNUNET_RECLAIM_Ticket ticket;
+
   for (op = handle->op_head; NULL != op; op = op->next)
     if (op->r_id == r_id)
       break;
@@ -649,41 +644,41 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg)
   if ((NULL == op) && (NULL == it))
     return;
   if (NULL != op)
-  {
-    GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op);
-    if (0 ==
-        memcmp (&msg->ticket, &ticket, sizeof (struct GNUNET_RECLAIM_Ticket)))
     {
-      if (NULL != op->tr_cb)
-        op->tr_cb (op->cls, NULL);
-    }
-    else
-    {
-      if (NULL != op->tr_cb)
-        op->tr_cb (op->cls, &msg->ticket);
+      GNUNET_CONTAINER_DLL_remove(handle->op_head, handle->op_tail, op);
+      if (0 ==
+          memcmp(&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_Ticket)))
+        {
+          if (NULL != op->tr_cb)
+            op->tr_cb(op->cls, NULL);
+        }
+      else
+        {
+          if (NULL != op->tr_cb)
+            op->tr_cb(op->cls, &msg->ticket);
+        }
+      free_op(op);
+      return;
     }
-    free_op (op);
-    return;
-  }
   else if (NULL != it)
-  {
-    if (0 ==
-        memcmp (&msg->ticket, &ticket, sizeof (struct GNUNET_RECLAIM_Ticket)))
-    {
-      GNUNET_CONTAINER_DLL_remove (handle->ticket_it_head,
-                                   handle->ticket_it_tail,
-                                   it);
-      it->finish_cb (it->finish_cb_cls);
-      GNUNET_free (it);
-    }
-    else
     {
-      if (NULL != it->tr_cb)
-        it->tr_cb (it->cls, &msg->ticket);
+      if (0 ==
+          memcmp(&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_Ticket)))
+        {
+          GNUNET_CONTAINER_DLL_remove(handle->ticket_it_head,
+                                      handle->ticket_it_tail,
+                                      it);
+          it->finish_cb(it->finish_cb_cls);
+          GNUNET_free(it);
+        }
+      else
+        {
+          if (NULL != it->tr_cb)
+            it->tr_cb(it->cls, &msg->ticket);
+        }
+      return;
     }
-    return;
-  }
-  GNUNET_break (0);
+  GNUNET_break(0);
 }
 
 
@@ -695,15 +690,15 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg)
  * @param msg the message we received
  */
 static void
-handle_revoke_ticket_result (void *cls,
-                             const struct RevokeTicketResultMessage *msg)
+handle_revoke_ticket_result(void *cls,
+                            const struct RevokeTicketResultMessage *msg)
 {
   struct GNUNET_RECLAIM_Handle *h = cls;
   struct GNUNET_RECLAIM_Operation *op;
-  uint32_t r_id = ntohl (msg->id);
+  uint32_t r_id = ntohl(msg->id);
   int32_t success;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing revocation result.\n");
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Processing revocation result.\n");
 
 
   for (op = h->op_head; NULL != op; op = op->next)
@@ -711,17 +706,17 @@ handle_revoke_ticket_result (void *cls,
       break;
   if (NULL == op)
     return;
-  success = ntohl (msg->success);
+  success = ntohl(msg->success);
   {
     if (NULL != op->rvk_cb)
-    {
-      op->rvk_cb (op->cls, success, NULL);
-    }
-    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-    free_op (op);
+      {
+        op->rvk_cb(op->cls, success, NULL);
+      }
+    GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, op);
+    free_op(op);
     return;
   }
-  GNUNET_assert (0);
+  GNUNET_assert(0);
 }
 
 
@@ -731,41 +726,41 @@ handle_revoke_ticket_result (void *cls,
  * @param h handle to the reclaim service.
  */
 static void
-reconnect (struct GNUNET_RECLAIM_Handle *h)
+reconnect(struct GNUNET_RECLAIM_Handle *h)
 {
   struct GNUNET_MQ_MessageHandler handlers[] =
-    {GNUNET_MQ_hd_fixed_size (success_response,
-                              GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE,
-                              struct SuccessResultMessage,
-                              h),
-     GNUNET_MQ_hd_var_size (attribute_result,
-                            GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT,
-                            struct AttributeResultMessage,
+  { GNUNET_MQ_hd_fixed_size(success_response,
+                            GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE,
+                            struct SuccessResultMessage,
                             h),
-     GNUNET_MQ_hd_fixed_size (ticket_result,
-                              GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT,
-                              struct TicketResultMessage,
-                              h),
-     GNUNET_MQ_hd_var_size (consume_ticket_result,
-                            GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT,
-                            struct ConsumeTicketResultMessage,
+    GNUNET_MQ_hd_var_size(attribute_result,
+                          GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT,
+                          struct AttributeResultMessage,
+                          h),
+    GNUNET_MQ_hd_fixed_size(ticket_result,
+                            GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT,
+                            struct TicketResultMessage,
                             h),
-     GNUNET_MQ_hd_fixed_size (revoke_ticket_result,
-                              GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT,
-                              struct RevokeTicketResultMessage,
-                              h),
-     GNUNET_MQ_handler_end ()};
+    GNUNET_MQ_hd_var_size(consume_ticket_result,
+                          GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT,
+                          struct ConsumeTicketResultMessage,
+                          h),
+    GNUNET_MQ_hd_fixed_size(revoke_ticket_result,
+                            GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT,
+                            struct RevokeTicketResultMessage,
+                            h),
+    GNUNET_MQ_handler_end() };
   struct GNUNET_RECLAIM_Operation *op;
 
-  GNUNET_assert (NULL == h->mq);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to reclaim service.\n");
+  GNUNET_assert(NULL == h->mq);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Connecting to reclaim service.\n");
 
   h->mq =
-    GNUNET_CLIENT_connect (h->cfg, "reclaim", handlers, &mq_error_handler, h);
+    GNUNET_CLIENT_connect(h->cfg, "reclaim", handlers, &mq_error_handler, h);
   if (NULL == h->mq)
     return;
   for (op = h->op_head; NULL != op; op = op->next)
-    GNUNET_MQ_send_copy (h->mq, op->env);
+    GNUNET_MQ_send_copy(h->mq, op->env);
 }
 
 
@@ -776,18 +771,18 @@ reconnect (struct GNUNET_RECLAIM_Handle *h)
  * @return handle to use
  */
 struct GNUNET_RECLAIM_Handle *
-GNUNET_RECLAIM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_RECLAIM_Handle *h;
 
-  h = GNUNET_new (struct GNUNET_RECLAIM_Handle);
+  h = GNUNET_new(struct GNUNET_RECLAIM_Handle);
   h->cfg = cfg;
-  reconnect (h);
+  reconnect(h);
   if (NULL == h->mq)
-  {
-    GNUNET_free (h);
-    return NULL;
-  }
+    {
+      GNUNET_free(h);
+      return NULL;
+    }
   return h;
 }
 
@@ -801,12 +796,12 @@ GNUNET_RECLAIM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param op operation to cancel
  */
 void
-GNUNET_RECLAIM_cancel (struct GNUNET_RECLAIM_Operation *op)
+GNUNET_RECLAIM_cancel(struct GNUNET_RECLAIM_Operation *op)
 {
   struct GNUNET_RECLAIM_Handle *h = op->h;
 
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
-  free_op (op);
+  GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, op);
+  free_op(op);
 }
 
 
@@ -816,21 +811,21 @@ GNUNET_RECLAIM_cancel (struct GNUNET_RECLAIM_Operation *op)
  * @param h handle to destroy
  */
 void
-GNUNET_RECLAIM_disconnect (struct GNUNET_RECLAIM_Handle *h)
+GNUNET_RECLAIM_disconnect(struct GNUNET_RECLAIM_Handle *h)
 {
-  GNUNET_assert (NULL != h);
+  GNUNET_assert(NULL != h);
   if (NULL != h->mq)
-  {
-    GNUNET_MQ_destroy (h->mq);
-    h->mq = NULL;
-  }
+    {
+      GNUNET_MQ_destroy(h->mq);
+      h->mq = NULL;
+    }
   if (NULL != h->reconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->reconnect_task);
-    h->reconnect_task = NULL;
-  }
-  GNUNET_assert (NULL == h->op_head);
-  GNUNET_free (h);
+    {
+      GNUNET_SCHEDULER_cancel(h->reconnect_task);
+      h->reconnect_task = NULL;
+    }
+  GNUNET_assert(NULL == h->op_head);
+  GNUNET_free(h);
 }
 
 /**
@@ -846,7 +841,7 @@ GNUNET_RECLAIM_disconnect (struct GNUNET_RECLAIM_Handle *h)
  * @return handle to abort the request
  */
 struct GNUNET_RECLAIM_Operation *
-GNUNET_RECLAIM_attribute_store (
+GNUNET_RECLAIM_attribute_store(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
   const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr,
@@ -858,25 +853,25 @@ GNUNET_RECLAIM_attribute_store (
   struct AttributeStoreMessage *sam;
   size_t attr_len;
 
-  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
+  op = GNUNET_new(struct GNUNET_RECLAIM_Operation);
   op->h = h;
   op->as_cb = cont;
   op->cls = cont_cls;
   op->r_id = h->r_id_gen++;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
-  attr_len = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (attr);
-  op->env = GNUNET_MQ_msg_extra (sam,
-                                 attr_len,
-                                 GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, op);
+  attr_len = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size(attr);
+  op->env = GNUNET_MQ_msg_extra(sam,
+                                attr_len,
+                                GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE);
   sam->identity = *pkey;
-  sam->id = htonl (op->r_id);
-  sam->exp = GNUNET_htonll (exp_interval->rel_value_us);
+  sam->id = htonl(op->r_id);
+  sam->exp = GNUNET_htonll(exp_interval->rel_value_us);
 
-  GNUNET_RECLAIM_ATTRIBUTE_serialize (attr, (char *) &sam[1]);
+  GNUNET_RECLAIM_ATTRIBUTE_serialize(attr, (char *)&sam[1]);
 
-  sam->attr_len = htons (attr_len);
+  sam->attr_len = htons(attr_len);
   if (NULL != h->mq)
-    GNUNET_MQ_send_copy (h->mq, op->env);
+    GNUNET_MQ_send_copy(h->mq, op->env);
   return op;
 }
 
@@ -893,7 +888,7 @@ GNUNET_RECLAIM_attribute_store (
  * @return handle Used to to abort the request
  */
 struct GNUNET_RECLAIM_Operation *
-GNUNET_RECLAIM_attribute_delete (
+GNUNET_RECLAIM_attribute_delete(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey,
   const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr,
@@ -904,23 +899,23 @@ GNUNET_RECLAIM_attribute_delete (
   struct AttributeDeleteMessage *dam;
   size_t attr_len;
 
-  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
+  op = GNUNET_new(struct GNUNET_RECLAIM_Operation);
   op->h = h;
   op->as_cb = cont;
   op->cls = cont_cls;
   op->r_id = h->r_id_gen++;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
-  attr_len = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (attr);
-  op->env = GNUNET_MQ_msg_extra (dam,
-                                 attr_len,
-                                 GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, op);
+  attr_len = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size(attr);
+  op->env = GNUNET_MQ_msg_extra(dam,
+                                attr_len,
+                                GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE);
   dam->identity = *pkey;
-  dam->id = htonl (op->r_id);
-  GNUNET_RECLAIM_ATTRIBUTE_serialize (attr, (char *) &dam[1]);
+  dam->id = htonl(op->r_id);
+  GNUNET_RECLAIM_ATTRIBUTE_serialize(attr, (char *)&dam[1]);
 
-  dam->attr_len = htons (attr_len);
+  dam->attr_len = htons(attr_len);
   if (NULL != h->mq)
-    GNUNET_MQ_send_copy (h->mq, op->env);
+    GNUNET_MQ_send_copy(h->mq, op->env);
   return op;
 }
 
@@ -950,7 +945,7 @@ GNUNET_RECLAIM_attribute_delete (
  * @return an iterator Handle to use for iteration
  */
 struct GNUNET_RECLAIM_AttributeIterator *
-GNUNET_RECLAIM_get_attributes_start (
+GNUNET_RECLAIM_get_attributes_start(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
   GNUNET_SCHEDULER_TaskCallback error_cb,
@@ -966,7 +961,7 @@ GNUNET_RECLAIM_get_attributes_start (
   uint32_t rid;
 
   rid = h->r_id_gen++;
-  it = GNUNET_new (struct GNUNET_RECLAIM_AttributeIterator);
+  it = GNUNET_new(struct GNUNET_RECLAIM_AttributeIterator);
   it->h = h;
   it->error_cb = error_cb;
   it->error_cb_cls = error_cb_cls;
@@ -976,15 +971,15 @@ GNUNET_RECLAIM_get_attributes_start (
   it->proc_cls = proc_cls;
   it->r_id = rid;
   it->identity = *identity;
-  GNUNET_CONTAINER_DLL_insert_tail (h->it_head, h->it_tail, it);
+  GNUNET_CONTAINER_DLL_insert_tail(h->it_head, h->it_tail, it);
   env =
-    GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START);
-  msg->id = htonl (rid);
+    GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START);
+  msg->id = htonl(rid);
   msg->identity = *identity;
   if (NULL == h->mq)
     it->env = env;
   else
-    GNUNET_MQ_send (h->mq, env);
+    GNUNET_MQ_send(h->mq, env);
   return it;
 }
 
@@ -996,16 +991,16 @@ GNUNET_RECLAIM_get_attributes_start (
  * @param it the iterator
  */
 void
-GNUNET_RECLAIM_get_attributes_next (struct GNUNET_RECLAIM_AttributeIterator *it)
+GNUNET_RECLAIM_get_attributes_next(struct GNUNET_RECLAIM_AttributeIterator *it)
 {
   struct GNUNET_RECLAIM_Handle *h = it->h;
   struct AttributeIterationNextMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
   env =
-    GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT);
-  msg->id = htonl (it->r_id);
-  GNUNET_MQ_send (h->mq, env);
+    GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT);
+  msg->id = htonl(it->r_id);
+  GNUNET_MQ_send(h->mq, env);
 }
 
 
@@ -1017,20 +1012,20 @@ GNUNET_RECLAIM_get_attributes_next (struct GNUNET_RECLAIM_AttributeIterator *it)
  * @param it the iterator
  */
 void
-GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it)
+GNUNET_RECLAIM_get_attributes_stop(struct GNUNET_RECLAIM_AttributeIterator *it)
 {
   struct GNUNET_RECLAIM_Handle *h = it->h;
   struct GNUNET_MQ_Envelope *env;
   struct AttributeIterationStopMessage *msg;
 
   if (NULL != h->mq)
-  {
-    env =
-      GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP);
-    msg->id = htonl (it->r_id);
-    GNUNET_MQ_send (h->mq, env);
-  }
-  free_it (it);
+    {
+      env =
+        GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP);
+      msg->id = htonl(it->r_id);
+      GNUNET_MQ_send(h->mq, env);
+    }
+  free_it(it);
 }
 
 
@@ -1048,7 +1043,7 @@ GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it)
  * @return handle to abort the operation
  */
 struct GNUNET_RECLAIM_Operation *
-GNUNET_RECLAIM_ticket_issue (
+GNUNET_RECLAIM_ticket_issue(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *iss,
   const struct GNUNET_CRYPTO_EcdsaPublicKey *rp,
@@ -1059,26 +1054,27 @@ GNUNET_RECLAIM_ticket_issue (
   struct GNUNET_RECLAIM_Operation *op;
   struct IssueTicketMessage *tim;
   size_t attr_len;
-  fprintf (stderr, "Issuing ticket\n");
-  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
+
+  fprintf(stderr, "Issuing ticket\n");
+  op = GNUNET_new(struct GNUNET_RECLAIM_Operation);
   op->h = h;
   op->tr_cb = cb;
   op->cls = cb_cls;
   op->r_id = h->r_id_gen++;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
-  attr_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size (attrs);
-  op->env = GNUNET_MQ_msg_extra (tim,
-                                 attr_len,
-                                 GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, op);
+  attr_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size(attrs);
+  op->env = GNUNET_MQ_msg_extra(tim,
+                                attr_len,
+                                GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET);
   tim->identity = *iss;
   tim->rp = *rp;
-  tim->id = htonl (op->r_id);
+  tim->id = htonl(op->r_id);
 
-  GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, (char *) &tim[1]);
+  GNUNET_RECLAIM_ATTRIBUTE_list_serialize(attrs, (char *)&tim[1]);
 
-  tim->attr_len = htons (attr_len);
+  tim->attr_len = htons(attr_len);
   if (NULL != h->mq)
-    GNUNET_MQ_send_copy (h->mq, op->env);
+    GNUNET_MQ_send_copy(h->mq, op->env);
   return op;
 }
 
@@ -1096,7 +1092,7 @@ GNUNET_RECLAIM_ticket_issue (
  * @return handle to abort the operation
  */
 struct GNUNET_RECLAIM_Operation *
-GNUNET_RECLAIM_ticket_consume (
+GNUNET_RECLAIM_ticket_consume(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
   const struct GNUNET_RECLAIM_Ticket *ticket,
@@ -1106,18 +1102,18 @@ GNUNET_RECLAIM_ticket_consume (
   struct GNUNET_RECLAIM_Operation *op;
   struct ConsumeTicketMessage *ctm;
 
-  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
+  op = GNUNET_new(struct GNUNET_RECLAIM_Operation);
   op->h = h;
   op->ar_cb = cb;
   op->cls = cb_cls;
   op->r_id = h->r_id_gen++;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
-  op->env = GNUNET_MQ_msg (ctm, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, op);
+  op->env = GNUNET_MQ_msg(ctm, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET);
   ctm->identity = *identity;
-  ctm->id = htonl (op->r_id);
+  ctm->id = htonl(op->r_id);
   ctm->ticket = *ticket;
   if (NULL != h->mq)
-    GNUNET_MQ_send_copy (h->mq, op->env);
+    GNUNET_MQ_send_copy(h->mq, op->env);
   return op;
 }
 
@@ -1140,7 +1136,7 @@ GNUNET_RECLAIM_ticket_consume (
  * @return an iterator handle to use for iteration
  */
 struct GNUNET_RECLAIM_TicketIterator *
-GNUNET_RECLAIM_ticket_iteration_start (
+GNUNET_RECLAIM_ticket_iteration_start(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
   GNUNET_SCHEDULER_TaskCallback error_cb,
@@ -1156,7 +1152,7 @@ GNUNET_RECLAIM_ticket_iteration_start (
   uint32_t rid;
 
   rid = h->r_id_gen++;
-  it = GNUNET_new (struct GNUNET_RECLAIM_TicketIterator);
+  it = GNUNET_new(struct GNUNET_RECLAIM_TicketIterator);
   it->h = h;
   it->error_cb = error_cb;
   it->error_cb_cls = error_cb_cls;
@@ -1165,14 +1161,14 @@ GNUNET_RECLAIM_ticket_iteration_start (
   it->tr_cb = proc;
   it->cls = proc_cls;
   it->r_id = rid;
-  GNUNET_CONTAINER_DLL_insert_tail (h->ticket_it_head, h->ticket_it_tail, it);
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START);
-  msg->id = htonl (rid);
+  GNUNET_CONTAINER_DLL_insert_tail(h->ticket_it_head, h->ticket_it_tail, it);
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START);
+  msg->id = htonl(rid);
   msg->identity = *identity;
   if (NULL == h->mq)
     it->env = env;
   else
-    GNUNET_MQ_send (h->mq, env);
+    GNUNET_MQ_send(h->mq, env);
   return it;
 }
 
@@ -1184,15 +1180,15 @@ GNUNET_RECLAIM_ticket_iteration_start (
  * @param it the iterator
  */
 void
-GNUNET_RECLAIM_ticket_iteration_next (struct GNUNET_RECLAIM_TicketIterator *it)
+GNUNET_RECLAIM_ticket_iteration_next(struct GNUNET_RECLAIM_TicketIterator *it)
 {
   struct GNUNET_RECLAIM_Handle *h = it->h;
   struct TicketIterationNextMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT);
-  msg->id = htonl (it->r_id);
-  GNUNET_MQ_send (h->mq, env);
+  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT);
+  msg->id = htonl(it->r_id);
+  GNUNET_MQ_send(h->mq, env);
 }
 
 
@@ -1204,20 +1200,20 @@ GNUNET_RECLAIM_ticket_iteration_next (struct GNUNET_RECLAIM_TicketIterator *it)
  * @param it the iterator
  */
 void
-GNUNET_RECLAIM_ticket_iteration_stop (struct GNUNET_RECLAIM_TicketIterator *it)
+GNUNET_RECLAIM_ticket_iteration_stop(struct GNUNET_RECLAIM_TicketIterator *it)
 {
   struct GNUNET_RECLAIM_Handle *h = it->h;
   struct GNUNET_MQ_Envelope *env;
   struct TicketIterationStopMessage *msg;
 
   if (NULL != h->mq)
-  {
-    env =
-      GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP);
-    msg->id = htonl (it->r_id);
-    GNUNET_MQ_send (h->mq, env);
-  }
-  GNUNET_free (it);
+    {
+      env =
+        GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP);
+      msg->id = htonl(it->r_id);
+      GNUNET_MQ_send(h->mq, env);
+    }
+  GNUNET_free(it);
 }
 
 
@@ -1235,7 +1231,7 @@ GNUNET_RECLAIM_ticket_iteration_stop (struct GNUNET_RECLAIM_TicketIterator *it)
  * @return handle to abort the operation
  */
 struct GNUNET_RECLAIM_Operation *
-GNUNET_RECLAIM_ticket_revoke (
+GNUNET_RECLAIM_ticket_revoke(
   struct GNUNET_RECLAIM_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
   const struct GNUNET_RECLAIM_Ticket *ticket,
@@ -1247,21 +1243,21 @@ GNUNET_RECLAIM_ticket_revoke (
   uint32_t rid;
 
   rid = h->r_id_gen++;
-  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
+  op = GNUNET_new(struct GNUNET_RECLAIM_Operation);
   op->h = h;
   op->rvk_cb = cb;
   op->cls = cb_cls;
   op->r_id = rid;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
-  op->env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET);
-  msg->id = htonl (rid);
+  GNUNET_CONTAINER_DLL_insert_tail(h->op_head, h->op_tail, op);
+  op->env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET);
+  msg->id = htonl(rid);
   msg->identity = *identity;
   msg->ticket = *ticket;
   if (NULL != h->mq)
-  {
-    GNUNET_MQ_send (h->mq, op->env);
-    op->env = NULL;
-  }
+    {
+      GNUNET_MQ_send(h->mq, op->env);
+      op->env = NULL;
+    }
   return op;
 }