global reindent, now with uncrustify hook enabled

1 files changed, 286 insertions, 282 deletions

diff --git a/src/reclaim/reclaim_api.c b/src/reclaim/reclaim_api.c
index a8790cd8e..3e03d973b 100644
--- a/src/reclaim/reclaim_api.c
+++ b/src/reclaim/reclaim_api.c
@@ -32,13 +32,14 @@
 #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.
    */
@@ -100,7 +101,8 @@ struct GNUNET_RECLAIM_Operation {
 /**
  * Handle for a ticket iterator operation
  */
-struct GNUNET_RECLAIM_TicketIterator {
+struct GNUNET_RECLAIM_TicketIterator
+{
   /**
    * Kept in a DLL.
    */
@@ -162,7 +164,8 @@ struct GNUNET_RECLAIM_TicketIterator {
 /**
  * Handle for a attribute iterator operation
  */
-struct GNUNET_RECLAIM_AttributeIterator {
+struct GNUNET_RECLAIM_AttributeIterator
+{
   /**
    * Kept in a DLL.
    */
@@ -229,7 +232,8 @@ struct GNUNET_RECLAIM_AttributeIterator {
 /**
  * Handle to the service.
  */
-struct GNUNET_RECLAIM_Handle {
+struct GNUNET_RECLAIM_Handle
+{
   /**
    * Configuration to use.
    */
@@ -313,7 +317,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);
 
 
 /**
@@ -322,12 +326,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);
 }
 
 
@@ -337,16 +341,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);
 }
 
 
@@ -356,14 +360,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);
 }
 
 /**
@@ -372,13 +376,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);
 }
 
 
@@ -391,11 +395,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);
 }
 
 
@@ -407,11 +411,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;
 
@@ -421,20 +425,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);
 }
 
 
@@ -447,19 +451,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);
+  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;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -472,16 +476,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)
@@ -494,28 +498,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)
       {
-        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);
+        op->ar_cb (op->cls, &msg->identity, NULL);
       }
-    GNUNET_CONTAINER_DLL_remove(h->op_head, h->op_tail, op);
-    free_op(op);
-    GNUNET_free_non_null(attrs);
+      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);
     return;
   }
-  GNUNET_assert(0);
+  GNUNET_assert (0);
 }
 
 
@@ -528,18 +532,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);
+  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;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -552,17 +556,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)
@@ -575,47 +579,47 @@ handle_attribute_result(void *cls, const struct AttributeResultMessage *msg)
     return;
 
   if ((0 ==
-       (memcmp(&msg->identity, &identity_dummy, sizeof(identity_dummy)))))
+       (memcmp (&msg->identity, &identity_dummy, sizeof(identity_dummy)))))
+  {
+    if ((NULL == it) && (NULL == op))
     {
-      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);
-        }
+      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;
+  }
 
   {
     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);
 }
 
 
@@ -627,12 +631,12 @@ 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)
@@ -644,41 +648,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)))
     {
-      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;
+      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;
+  }
   else if (NULL != it)
+  {
+    if (0 ==
+        memcmp (&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_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;
+      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);
     }
-  GNUNET_break(0);
+    return;
+  }
+  GNUNET_break (0);
 }
 
 
@@ -690,15 +694,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)
@@ -706,17 +710,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);
 }
 
 
@@ -726,41 +730,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,
-                          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,
-                          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_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,
+                           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,
+                           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);
 }
 
 
@@ -771,18 +775,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;
 }
 
@@ -796,12 +800,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);
 }
 
 
@@ -811,21 +815,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);
 }
 
 /**
@@ -841,7 +845,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,
@@ -853,25 +857,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;
 }
 
@@ -888,7 +892,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,
@@ -899,23 +903,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;
 }
 
@@ -945,7 +949,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,
@@ -961,7 +965,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;
@@ -971,15 +975,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;
 }
 
@@ -991,16 +995,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);
 }
 
 
@@ -1012,20 +1016,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);
 }
 
 
@@ -1043,7 +1047,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,
@@ -1055,26 +1059,26 @@ GNUNET_RECLAIM_ticket_issue(
   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;
 }
 
@@ -1092,7 +1096,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,
@@ -1102,18 +1106,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;
 }
 
@@ -1136,7 +1140,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,
@@ -1152,7 +1156,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;
@@ -1161,14 +1165,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;
 }
 
@@ -1180,15 +1184,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);
 }
 
 
@@ -1200,20 +1204,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);
 }
 
 
@@ -1231,7 +1235,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,
@@ -1243,21 +1247,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;
 }