global reindent, now with uncrustify hook enabled

1 files changed, 603 insertions, 588 deletions

diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c
index 23a5db1ed..440656343 100644
--- a/src/reclaim/gnunet-service-reclaim.c
+++ b/src/reclaim/gnunet-service-reclaim.c
@@ -58,7 +58,8 @@ struct IdpClient;
 /**
  * A ticket iteration operation.
  */
-struct TicketIteration {
+struct TicketIteration
+{
   /**
    * DLL
    */
@@ -89,7 +90,8 @@ struct TicketIteration {
 /**
  * An attribute iteration operation.
  */
-struct AttributeIterator {
+struct AttributeIterator
+{
   /**
    * Next element in the DLL
    */
@@ -125,7 +127,8 @@ struct AttributeIterator {
 /**
  * An idp client
  */
-struct IdpClient {
+struct IdpClient
+{
   /**
    * DLL
    */
@@ -224,7 +227,8 @@ struct IdpClient {
 /**
  * Handle for attribute deletion request
  */
-struct AttributeDeleteHandle {
+struct AttributeDeleteHandle
+{
   /**
    * DLL
    */
@@ -286,7 +290,8 @@ struct AttributeDeleteHandle {
 /**
  * Handle for attribute store request
  */
-struct AttributeStoreHandle {
+struct AttributeStoreHandle
+{
   /**
    * DLL
    */
@@ -337,7 +342,8 @@ struct AttributeStoreHandle {
 /**
  * Handle for ticket consume request
  */
-struct ConsumeTicketOperation {
+struct ConsumeTicketOperation
+{
   /**
    * DLL
    */
@@ -368,7 +374,8 @@ struct ConsumeTicketOperation {
 /**
  * Ticket revocation request handle
  */
-struct TicketRevocationOperation {
+struct TicketRevocationOperation
+{
   /**
    * DLL
    */
@@ -399,7 +406,8 @@ struct TicketRevocationOperation {
 /**
  * Ticket issue operation handle
  */
-struct TicketIssueOperation {
+struct TicketIssueOperation
+{
   /**
    * DLL
    */
@@ -439,30 +447,30 @@ static struct IdpClient *client_list_tail = NULL;
  * @param adh the attribute to cleanup
  */
 static void
-cleanup_adh(struct AttributeDeleteHandle *adh)
+cleanup_adh (struct AttributeDeleteHandle *adh)
 {
   struct TicketRecordsEntry *le;
 
   if (NULL != adh->ns_it)
-    GNUNET_NAMESTORE_zone_iteration_stop(adh->ns_it);
+    GNUNET_NAMESTORE_zone_iteration_stop (adh->ns_it);
   if (NULL != adh->ns_qe)
-    GNUNET_NAMESTORE_cancel(adh->ns_qe);
+    GNUNET_NAMESTORE_cancel (adh->ns_qe);
   if (NULL != adh->label)
-    GNUNET_free(adh->label);
+    GNUNET_free (adh->label);
   if (NULL != adh->claim)
-    GNUNET_free(adh->claim);
+    GNUNET_free (adh->claim);
   while (NULL != (le = adh->tickets_to_update_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(adh->tickets_to_update_head,
-                                  adh->tickets_to_update_tail,
-                                  le);
-      if (NULL != le->label)
-        GNUNET_free(le->label);
-      if (NULL != le->data)
-        GNUNET_free(le->data);
-      GNUNET_free(le);
-    }
-  GNUNET_free(adh);
+  {
+    GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head,
+                                 adh->tickets_to_update_tail,
+                                 le);
+    if (NULL != le->label)
+      GNUNET_free (le->label);
+    if (NULL != le->data)
+      GNUNET_free (le->data);
+    GNUNET_free (le);
+  }
+  GNUNET_free (adh);
 }
 
 
@@ -472,13 +480,13 @@ cleanup_adh(struct AttributeDeleteHandle *adh)
  * @param handle handle to clean up
  */
 static void
-cleanup_as_handle(struct AttributeStoreHandle *ash)
+cleanup_as_handle (struct AttributeStoreHandle *ash)
 {
   if (NULL != ash->ns_qe)
-    GNUNET_NAMESTORE_cancel(ash->ns_qe);
+    GNUNET_NAMESTORE_cancel (ash->ns_qe);
   if (NULL != ash->claim)
-    GNUNET_free(ash->claim);
-  GNUNET_free(ash);
+    GNUNET_free (ash->claim);
+  GNUNET_free (ash);
 }
 
 
@@ -488,7 +496,7 @@ cleanup_as_handle(struct AttributeStoreHandle *ash)
  * @param idp the client to clean up
  */
 static void
-cleanup_client(struct IdpClient *idp)
+cleanup_client (struct IdpClient *idp)
 {
   struct AttributeIterator *ai;
   struct TicketIteration *ti;
@@ -499,52 +507,52 @@ cleanup_client(struct IdpClient *idp)
   struct AttributeDeleteHandle *adh;
 
   while (NULL != (iss = idp->issue_op_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->issue_op_head, idp->issue_op_tail, iss);
-      GNUNET_free(iss);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->issue_op_head, idp->issue_op_tail, iss);
+    GNUNET_free (iss);
+  }
   while (NULL != (ct = idp->consume_op_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->consume_op_head,
-                                  idp->consume_op_tail,
-                                  ct);
-      if (NULL != ct->ch)
-        RECLAIM_TICKETS_consume_cancel(ct->ch);
-      GNUNET_free(ct);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->consume_op_head,
+                                 idp->consume_op_tail,
+                                 ct);
+    if (NULL != ct->ch)
+      RECLAIM_TICKETS_consume_cancel (ct->ch);
+    GNUNET_free (ct);
+  }
   while (NULL != (as = idp->store_op_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->store_op_head, idp->store_op_tail, as);
-      cleanup_as_handle(as);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->store_op_head, idp->store_op_tail, as);
+    cleanup_as_handle (as);
+  }
   while (NULL != (adh = idp->delete_op_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->delete_op_head, idp->delete_op_tail, adh);
-      cleanup_adh(adh);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->delete_op_head, idp->delete_op_tail, adh);
+    cleanup_adh (adh);
+  }
 
   while (NULL != (ai = idp->attr_iter_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->attr_iter_head, idp->attr_iter_tail, ai);
-      GNUNET_free(ai);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
+    GNUNET_free (ai);
+  }
   while (NULL != (rop = idp->revoke_op_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->revoke_op_head, idp->revoke_op_tail, rop);
-      if (NULL != rop->rh)
-        RECLAIM_TICKETS_revoke_cancel(rop->rh);
-      GNUNET_free(rop);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->revoke_op_head, idp->revoke_op_tail, rop);
+    if (NULL != rop->rh)
+      RECLAIM_TICKETS_revoke_cancel (rop->rh);
+    GNUNET_free (rop);
+  }
   while (NULL != (ti = idp->ticket_iter_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(idp->ticket_iter_head,
-                                  idp->ticket_iter_tail,
-                                  ti);
-      if (NULL != ti->iter)
-        RECLAIM_TICKETS_iteration_stop(ti->iter);
-      GNUNET_free(ti);
-    }
-  GNUNET_free(idp);
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->ticket_iter_head,
+                                 idp->ticket_iter_tail,
+                                 ti);
+    if (NULL != ti->iter)
+      RECLAIM_TICKETS_iteration_stop (ti->iter);
+    GNUNET_free (ti);
+  }
+  GNUNET_free (idp);
 }
 
 
@@ -552,24 +560,24 @@ cleanup_client(struct IdpClient *idp)
  * Cleanup task
  */
 static void
-cleanup()
+cleanup ()
 {
   struct IdpClient *cl;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
 
   while (NULL != (cl = client_list_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(client_list_head,
-                                  client_list_tail,
-                                  cl);
-      cleanup_client(cl);
-    }
-  RECLAIM_TICKETS_deinit();
+  {
+    GNUNET_CONTAINER_DLL_remove (client_list_head,
+                                 client_list_tail,
+                                 cl);
+    cleanup_client (cl);
+  }
+  RECLAIM_TICKETS_deinit ();
   if (NULL != timeout_task)
-    GNUNET_SCHEDULER_cancel(timeout_task);
+    GNUNET_SCHEDULER_cancel (timeout_task);
   if (NULL != nsh)
-    GNUNET_NAMESTORE_disconnect(nsh);
+    GNUNET_NAMESTORE_disconnect (nsh);
 }
 
 
@@ -579,10 +587,10 @@ cleanup()
  * @param cls NULL
  */
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
-  cleanup();
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
+  cleanup ();
 }
 
 
@@ -595,24 +603,24 @@ do_shutdown(void *cls)
  * @param success the success status of the request
  */
 static void
-send_ticket_result(const struct IdpClient *client,
-                   uint32_t r_id,
-                   const struct GNUNET_RECLAIM_Ticket *ticket,
-                   uint32_t success)
+send_ticket_result (const struct IdpClient *client,
+                    uint32_t r_id,
+                    const struct GNUNET_RECLAIM_Ticket *ticket,
+                    uint32_t success)
 {
   struct TicketResultMessage *irm;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg(irm,
-                      GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT);
+  env = GNUNET_MQ_msg (irm,
+                       GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT);
   if (NULL != ticket)
-    {
-      irm->ticket = *ticket;
-    }
+  {
+    irm->ticket = *ticket;
+  }
   // TODO add success member
-  irm->id = htonl(r_id);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
-  GNUNET_MQ_send(client->mq, env);
+  irm->id = htonl (r_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
+  GNUNET_MQ_send (client->mq, env);
 }
 
 
@@ -625,28 +633,28 @@ send_ticket_result(const struct IdpClient *client,
  * @param emsg error message (NULL of success is GNUNET_OK)
  */
 static void
-issue_ticket_result_cb(void *cls,
-                       struct GNUNET_RECLAIM_Ticket *ticket,
-                       int32_t success,
-                       const char *emsg)
+issue_ticket_result_cb (void *cls,
+                        struct GNUNET_RECLAIM_Ticket *ticket,
+                        int32_t success,
+                        const char *emsg)
 {
   struct TicketIssueOperation *tio = cls;
 
   if (GNUNET_OK != success)
-    {
-      send_ticket_result(tio->client, tio->r_id, NULL, GNUNET_SYSERR);
-      GNUNET_CONTAINER_DLL_remove(tio->client->issue_op_head,
-                                  tio->client->issue_op_tail,
-                                  tio);
-      GNUNET_free(tio);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
-      return;
-    }
-  send_ticket_result(tio->client, tio->r_id, ticket, GNUNET_SYSERR);
-  GNUNET_CONTAINER_DLL_remove(tio->client->issue_op_head,
-                              tio->client->issue_op_tail,
-                              tio);
-  GNUNET_free(tio);
+  {
+    send_ticket_result (tio->client, tio->r_id, NULL, GNUNET_SYSERR);
+    GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
+                                 tio->client->issue_op_tail,
+                                 tio);
+    GNUNET_free (tio);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
+    return;
+  }
+  send_ticket_result (tio->client, tio->r_id, ticket, GNUNET_SYSERR);
+  GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
+                               tio->client->issue_op_tail,
+                               tio);
+  GNUNET_free (tio);
 }
 
 
@@ -658,16 +666,16 @@ issue_ticket_result_cb(void *cls,
  * @return GNUNET_OK if message is ok
  */
 static int
-check_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
+check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
 {
   uint16_t size;
 
-  size = ntohs(im->header.size);
+  size = ntohs (im->header.size);
   if (size <= sizeof(struct IssueTicketMessage))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -679,27 +687,28 @@ check_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
  * @param im the message
  */
 static void
-handle_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
+handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
 {
   struct TicketIssueOperation *tio;
   struct IdpClient *idp = cls;
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs;
   size_t attrs_len;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
-  tio = GNUNET_new(struct TicketIssueOperation);
-  attrs_len = ntohs(im->attr_len);
-  attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize((char *)&im[1], attrs_len);
-  tio->r_id = ntohl(im->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
+  tio = GNUNET_new (struct TicketIssueOperation);
+  attrs_len = ntohs (im->attr_len);
+  attrs = GNUNET_RECLAIM_ATTRIBUTE_list_deserialize ((char *) &im[1],
+                                                     attrs_len);
+  tio->r_id = ntohl (im->id);
   tio->client = idp;
-  GNUNET_CONTAINER_DLL_insert(idp->issue_op_head, idp->issue_op_tail, tio);
-  RECLAIM_TICKETS_issue(&im->identity,
-                        attrs,
-                        &im->rp,
-                        &issue_ticket_result_cb,
-                        tio);
-  GNUNET_SERVICE_client_continue(idp->client);
-  GNUNET_RECLAIM_ATTRIBUTE_list_destroy(attrs);
+  GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio);
+  RECLAIM_TICKETS_issue (&im->identity,
+                         attrs,
+                         &im->rp,
+                         &issue_ticket_result_cb,
+                         tio);
+  GNUNET_SERVICE_client_continue (idp->client);
+  GNUNET_RECLAIM_ATTRIBUTE_list_destroy (attrs);
 }
 
 
@@ -715,22 +724,23 @@ handle_issue_ticket_message(void *cls, const struct IssueTicketMessage *im)
  * @param success revocation result (GNUNET_OK if successful)
  */
 static void
-revoke_result_cb(void *cls, int32_t success)
+revoke_result_cb (void *cls, int32_t success)
 {
   struct TicketRevocationOperation *rop = cls;
   struct GNUNET_MQ_Envelope *env;
   struct RevokeTicketResultMessage *trm;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending REVOKE_TICKET_RESULT message\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending REVOKE_TICKET_RESULT message\n");
   rop->rh = NULL;
-  env = GNUNET_MQ_msg(trm, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT);
-  trm->id = htonl(rop->r_id);
-  trm->success = htonl(success);
-  GNUNET_MQ_send(rop->client->mq, env);
-  GNUNET_CONTAINER_DLL_remove(rop->client->revoke_op_head,
-                              rop->client->revoke_op_tail,
-                              rop);
-  GNUNET_free(rop);
+  env = GNUNET_MQ_msg (trm, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT);
+  trm->id = htonl (rop->r_id);
+  trm->success = htonl (success);
+  GNUNET_MQ_send (rop->client->mq, env);
+  GNUNET_CONTAINER_DLL_remove (rop->client->revoke_op_head,
+                               rop->client->revoke_op_tail,
+                               rop);
+  GNUNET_free (rop);
 }
 
 
@@ -742,16 +752,16 @@ revoke_result_cb(void *cls, int32_t success)
  * @return GNUNET_OK if message is ok
  */
 static int
-check_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *im)
+check_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *im)
 {
   uint16_t size;
 
-  size = ntohs(im->header.size);
+  size = ntohs (im->header.size);
   if (size != sizeof(struct RevokeTicketMessage))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -763,19 +773,20 @@ check_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *im)
  * @param rm the message to handle
  */
 static void
-handle_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *rm)
+handle_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *rm)
 {
   struct TicketRevocationOperation *rop;
   struct IdpClient *idp = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
-  rop = GNUNET_new(struct TicketRevocationOperation);
-  rop->r_id = ntohl(rm->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
+  rop = GNUNET_new (struct TicketRevocationOperation);
+  rop->r_id = ntohl (rm->id);
   rop->client = idp;
-  GNUNET_CONTAINER_DLL_insert(idp->revoke_op_head, idp->revoke_op_tail, rop);
+  GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rop);
   rop->rh
-    = RECLAIM_TICKETS_revoke(&rm->ticket, &rm->identity, &revoke_result_cb, rop);
-  GNUNET_SERVICE_client_continue(idp->client);
+    = RECLAIM_TICKETS_revoke (&rm->ticket, &rm->identity, &revoke_result_cb,
+                              rop);
+  GNUNET_SERVICE_client_continue (idp->client);
 }
 
 
@@ -789,11 +800,11 @@ handle_revoke_ticket_message(void *cls, const struct RevokeTicketMessage *rm)
  * @param emsg error message (NULL if success=GNUNET_OK)
  */
 static void
-consume_result_cb(void *cls,
-                  const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-                  const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
-                  int32_t success,
-                  const char *emsg)
+consume_result_cb (void *cls,
+                   const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+                   const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
+                   int32_t success,
+                   const char *emsg)
 {
   struct ConsumeTicketOperation *cop = cls;
   struct ConsumeTicketResultMessage *crm;
@@ -802,25 +813,26 @@ consume_result_cb(void *cls,
   size_t attrs_len;
 
   if (GNUNET_OK != success)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
-    }
-  attrs_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size(attrs);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending CONSUME_TICKET_RESULT message\n");
-  env = GNUNET_MQ_msg_extra(crm,
-                            attrs_len,
-                            GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT);
-  crm->id = htonl(cop->r_id);
-  crm->attrs_len = htons(attrs_len);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
+  }
+  attrs_len = GNUNET_RECLAIM_ATTRIBUTE_list_serialize_get_size (attrs);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending CONSUME_TICKET_RESULT message\n");
+  env = GNUNET_MQ_msg_extra (crm,
+                             attrs_len,
+                             GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT);
+  crm->id = htonl (cop->r_id);
+  crm->attrs_len = htons (attrs_len);
   crm->identity = *identity;
-  crm->result = htonl(success);
-  data_tmp = (char *)&crm[1];
-  GNUNET_RECLAIM_ATTRIBUTE_list_serialize(attrs, data_tmp);
-  GNUNET_MQ_send(cop->client->mq, env);
-  GNUNET_CONTAINER_DLL_remove(cop->client->consume_op_head,
-                              cop->client->consume_op_tail,
-                              cop);
-  GNUNET_free(cop);
+  crm->result = htonl (success);
+  data_tmp = (char *) &crm[1];
+  GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, data_tmp);
+  GNUNET_MQ_send (cop->client->mq, env);
+  GNUNET_CONTAINER_DLL_remove (cop->client->consume_op_head,
+                               cop->client->consume_op_tail,
+                               cop);
+  GNUNET_free (cop);
 }
 
 
@@ -831,16 +843,16 @@ consume_result_cb(void *cls,
  * @param cm the message to handle
  */
 static int
-check_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
+check_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
 {
   uint16_t size;
 
-  size = ntohs(cm->header.size);
+  size = ntohs (cm->header.size);
   if (size != sizeof(struct ConsumeTicketMessage))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -852,19 +864,20 @@ check_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
  * @cm the message to handle
  */
 static void
-handle_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
+handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
 {
   struct ConsumeTicketOperation *cop;
   struct IdpClient *idp = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
-  cop = GNUNET_new(struct ConsumeTicketOperation);
-  cop->r_id = ntohl(cm->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
+  cop = GNUNET_new (struct ConsumeTicketOperation);
+  cop->r_id = ntohl (cm->id);
   cop->client = idp;
   cop->ch
-    = RECLAIM_TICKETS_consume(&cm->identity, &cm->ticket, &consume_result_cb, cop);
-  GNUNET_CONTAINER_DLL_insert(idp->consume_op_head, idp->consume_op_tail, cop);
-  GNUNET_SERVICE_client_continue(idp->client);
+    = RECLAIM_TICKETS_consume (&cm->identity, &cm->ticket, &consume_result_cb,
+                               cop);
+  GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop);
+  GNUNET_SERVICE_client_continue (idp->client);
 }
 
 /*****************************************
@@ -880,33 +893,33 @@ handle_consume_ticket_message(void *cls, const struct ConsumeTicketMessage *cm)
  * @param emsg error message (NULL if success=GNUNET_OK)
  */
 static void
-attr_store_cont(void *cls, int32_t success, const char *emsg)
+attr_store_cont (void *cls, int32_t success, const char *emsg)
 {
   struct AttributeStoreHandle *ash = cls;
   struct GNUNET_MQ_Envelope *env;
   struct SuccessResultMessage *acr_msg;
 
   ash->ns_qe = NULL;
-  GNUNET_CONTAINER_DLL_remove(ash->client->store_op_head,
-                              ash->client->store_op_tail,
-                              ash);
+  GNUNET_CONTAINER_DLL_remove (ash->client->store_op_head,
+                               ash->client->store_op_tail,
+                               ash);
 
   if (GNUNET_SYSERR == success)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Failed to store attribute %s\n",
-                 emsg);
-      cleanup_as_handle(ash);
-      GNUNET_SCHEDULER_add_now(&do_shutdown, NULL);
-      return;
-    }
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
-  env = GNUNET_MQ_msg(acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
-  acr_msg->id = htonl(ash->r_id);
-  acr_msg->op_result = htonl(GNUNET_OK);
-  GNUNET_MQ_send(ash->client->mq, env);
-  cleanup_as_handle(ash);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store attribute %s\n",
+                emsg);
+    cleanup_as_handle (ash);
+    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
+  env = GNUNET_MQ_msg (acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
+  acr_msg->id = htonl (ash->r_id);
+  acr_msg->op_result = htonl (GNUNET_OK);
+  GNUNET_MQ_send (ash->client->mq, env);
+  cleanup_as_handle (ash);
 }
 
 
@@ -916,7 +929,7 @@ attr_store_cont(void *cls, int32_t success, const char *emsg)
  * @param cls the AttributeStoreHandle
  */
 static void
-attr_store_task(void *cls)
+attr_store_task (void *cls)
 {
   struct AttributeStoreHandle *ash = cls;
   struct GNUNET_GNSRECORD_Data rd[1];
@@ -924,32 +937,32 @@ attr_store_task(void *cls)
   char *label;
   size_t buf_size;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
-  buf_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size(ash->claim);
-  buf = GNUNET_malloc(buf_size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
+  buf_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (ash->claim);
+  buf = GNUNET_malloc (buf_size);
   // Give the ash a new id if unset
   if (0 == ash->claim->id)
     ash->claim->id
-      = GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
-  GNUNET_RECLAIM_ATTRIBUTE_serialize(ash->claim, buf);
+      = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
+  GNUNET_RECLAIM_ATTRIBUTE_serialize (ash->claim, buf);
   label
-    = GNUNET_STRINGS_data_to_string_alloc(&ash->claim->id, sizeof(uint64_t));
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
+    = GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id, sizeof(uint64_t));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
 
   rd[0].data_size = buf_size;
   rd[0].data = buf;
   rd[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR;
   rd[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
   rd[0].expiration_time = ash->exp.rel_value_us;
-  ash->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
-                                              &ash->identity,
-                                              label,
-                                              1,
-                                              rd,
-                                              &attr_store_cont,
-                                              ash);
-  GNUNET_free(buf);
-  GNUNET_free(label);
+  ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
+                                               &ash->identity,
+                                               label,
+                                               1,
+                                               rd,
+                                               &attr_store_cont,
+                                               ash);
+  GNUNET_free (buf);
+  GNUNET_free (label);
 }
 
 
@@ -960,17 +973,17 @@ attr_store_task(void *cls)
  * @param sam the message to check
  */
 static int
-check_attribute_store_message(void *cls,
-                              const struct AttributeStoreMessage *sam)
+check_attribute_store_message (void *cls,
+                               const struct AttributeStoreMessage *sam)
 {
   uint16_t size;
 
-  size = ntohs(sam->header.size);
+  size = ntohs (sam->header.size);
   if (size <= sizeof(struct AttributeStoreMessage))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -982,29 +995,30 @@ check_attribute_store_message(void *cls,
  * @param sam the message to handle
  */
 static void
-handle_attribute_store_message(void *cls,
-                               const struct AttributeStoreMessage *sam)
+handle_attribute_store_message (void *cls,
+                                const struct AttributeStoreMessage *sam)
 {
   struct AttributeStoreHandle *ash;
   struct IdpClient *idp = cls;
   size_t data_len;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
 
-  data_len = ntohs(sam->attr_len);
+  data_len = ntohs (sam->attr_len);
 
-  ash = GNUNET_new(struct AttributeStoreHandle);
-  ash->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize((char *)&sam[1], data_len);
+  ash = GNUNET_new (struct AttributeStoreHandle);
+  ash->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &sam[1],
+                                                     data_len);
 
-  ash->r_id = ntohl(sam->id);
+  ash->r_id = ntohl (sam->id);
   ash->identity = sam->identity;
-  ash->exp.rel_value_us = GNUNET_ntohll(sam->exp);
-  GNUNET_CRYPTO_ecdsa_key_get_public(&sam->identity, &ash->identity_pkey);
+  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
+  GNUNET_CRYPTO_ecdsa_key_get_public (&sam->identity, &ash->identity_pkey);
 
-  GNUNET_SERVICE_client_continue(idp->client);
+  GNUNET_SERVICE_client_continue (idp->client);
   ash->client = idp;
-  GNUNET_CONTAINER_DLL_insert(idp->store_op_head, idp->store_op_tail, ash);
-  GNUNET_SCHEDULER_add_now(&attr_store_task, ash);
+  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
+  GNUNET_SCHEDULER_add_now (&attr_store_task, ash);
 }
 
 
@@ -1015,20 +1029,20 @@ handle_attribute_store_message(void *cls,
  * @param success the success status
  */
 static void
-send_delete_response(struct AttributeDeleteHandle *adh, int32_t success)
+send_delete_response (struct AttributeDeleteHandle *adh, int32_t success)
 {
   struct GNUNET_MQ_Envelope *env;
   struct SuccessResultMessage *acr_msg;
 
-  GNUNET_CONTAINER_DLL_remove(adh->client->delete_op_head,
-                              adh->client->delete_op_tail,
-                              adh);
+  GNUNET_CONTAINER_DLL_remove (adh->client->delete_op_head,
+                               adh->client->delete_op_tail,
+                               adh);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
-  env = GNUNET_MQ_msg(acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
-  acr_msg->id = htonl(adh->r_id);
-  acr_msg->op_result = htonl(success);
-  GNUNET_MQ_send(adh->client->mq, env);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
+  env = GNUNET_MQ_msg (acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
+  acr_msg->id = htonl (adh->r_id);
+  acr_msg->op_result = htonl (success);
+  GNUNET_MQ_send (adh->client->mq, env);
 }
 
 
@@ -1043,41 +1057,41 @@ send_delete_response(struct AttributeDeleteHandle *adh, int32_t success)
  * @param rd record data
  */
 static void
-ticket_iter(void *cls,
-            const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-            const char *label,
-            unsigned int rd_count,
-            const struct GNUNET_GNSRECORD_Data *rd)
+ticket_iter (void *cls,
+             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+             const char *label,
+             unsigned int rd_count,
+             const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct AttributeDeleteHandle *adh = cls;
   struct TicketRecordsEntry *le;
   int has_changed = GNUNET_NO;
 
   for (int i = 0; i < rd_count; i++)
-    {
-      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
-        continue;
-      if (0 != memcmp(rd[i].data, &adh->claim->id, sizeof(uint64_t)))
-        continue;
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Attribute to delete found (%s)\n",
-                 adh->label);
-      has_changed = GNUNET_YES;
-      break;
-    }
+  {
+    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
+      continue;
+    if (0 != memcmp (rd[i].data, &adh->claim->id, sizeof(uint64_t)))
+      continue;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Attribute to delete found (%s)\n",
+                adh->label);
+    has_changed = GNUNET_YES;
+    break;
+  }
   if (GNUNET_YES == has_changed)
-    {
-      le = GNUNET_new(struct TicketRecordsEntry);
-      le->data_size = GNUNET_GNSRECORD_records_get_size(rd_count, rd);
-      le->data = GNUNET_malloc(le->data_size);
-      le->rd_count = rd_count;
-      le->label = GNUNET_strdup(label);
-      GNUNET_GNSRECORD_records_serialize(rd_count, rd, le->data_size, le->data);
-      GNUNET_CONTAINER_DLL_insert(adh->tickets_to_update_head,
-                                  adh->tickets_to_update_tail,
-                                  le);
-    }
-  GNUNET_NAMESTORE_zone_iterator_next(adh->ns_it, 1);
+  {
+    le = GNUNET_new (struct TicketRecordsEntry);
+    le->data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
+    le->data = GNUNET_malloc (le->data_size);
+    le->rd_count = rd_count;
+    le->label = GNUNET_strdup (label);
+    GNUNET_GNSRECORD_records_serialize (rd_count, rd, le->data_size, le->data);
+    GNUNET_CONTAINER_DLL_insert (adh->tickets_to_update_head,
+                                 adh->tickets_to_update_tail,
+                                 le);
+  }
+  GNUNET_NAMESTORE_zone_iterator_next (adh->ns_it, 1);
 }
 
 
@@ -1086,7 +1100,7 @@ ticket_iter(void *cls,
  * @param cls our deletion handle
  */
 static void
-update_tickets(void *cls);
+update_tickets (void *cls);
 
 
 /**
@@ -1097,12 +1111,12 @@ update_tickets(void *cls);
  * @param emsg error message (NULL if success=GNUNET_OK)
  */
 static void
-ticket_updated(void *cls, int32_t success, const char *emsg)
+ticket_updated (void *cls, int32_t success, const char *emsg)
 {
   struct AttributeDeleteHandle *adh = cls;
 
   adh->ns_qe = NULL;
-  GNUNET_SCHEDULER_add_now(&update_tickets, adh);
+  GNUNET_SCHEDULER_add_now (&update_tickets, adh);
 }
 
 
@@ -1114,58 +1128,58 @@ ticket_updated(void *cls, int32_t success, const char *emsg)
  * @param cls our attribute deletion handle
  */
 static void
-update_tickets(void *cls)
+update_tickets (void *cls)
 {
   struct AttributeDeleteHandle *adh = cls;
   struct TicketRecordsEntry *le;
 
   if (NULL == adh->tickets_to_update_head)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Finished updatding tickets, success\n");
-      send_delete_response(adh, GNUNET_OK);
-      cleanup_adh(adh);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Updating %s\n",
-             adh->tickets_to_update_head->label);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Finished updatding tickets, success\n");
+    send_delete_response (adh, GNUNET_OK);
+    cleanup_adh (adh);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Updating %s\n",
+              adh->tickets_to_update_head->label);
   le = adh->tickets_to_update_head;
-  GNUNET_CONTAINER_DLL_remove(adh->tickets_to_update_head,
-                              adh->tickets_to_update_tail,
-                              le);
+  GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head,
+                               adh->tickets_to_update_tail,
+                               le);
   struct GNUNET_GNSRECORD_Data rd[le->rd_count];
   struct GNUNET_GNSRECORD_Data rd_new[le->rd_count - 1];
-  if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(le->data_size,
-                                                        le->data,
-                                                        le->rd_count,
-                                                        rd))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Unable to deserialize record data!\n");
-      send_delete_response(adh, GNUNET_SYSERR);
-      cleanup_adh(adh);
-      return;
-    }
+  if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (le->data_size,
+                                                         le->data,
+                                                         le->rd_count,
+                                                         rd))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Unable to deserialize record data!\n");
+    send_delete_response (adh, GNUNET_SYSERR);
+    cleanup_adh (adh);
+    return;
+  }
   int j = 0;
   for (int i = 0; i < le->rd_count; i++)
-    {
-      if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF == rd[i].record_type)
-          && (0 == memcmp(rd[i].data, &adh->claim->id, sizeof(uint64_t))))
-        continue;
-      rd_new[j] = rd[i];
-      j++;
-    }
-  adh->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
-                                              &adh->identity,
-                                              le->label,
-                                              j,
-                                              rd_new,
-                                              &ticket_updated,
-                                              adh);
-  GNUNET_free(le->label);
-  GNUNET_free(le->data);
-  GNUNET_free(le);
+  {
+    if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF == rd[i].record_type)
+        && (0 == memcmp (rd[i].data, &adh->claim->id, sizeof(uint64_t))))
+      continue;
+    rd_new[j] = rd[i];
+    j++;
+  }
+  adh->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
+                                               &adh->identity,
+                                               le->label,
+                                               j,
+                                               rd_new,
+                                               &ticket_updated,
+                                               adh);
+  GNUNET_free (le->label);
+  GNUNET_free (le->data);
+  GNUNET_free (le);
 }
 
 
@@ -1175,12 +1189,12 @@ update_tickets(void *cls)
  * @param cls our attribute deletion handle
  */
 static void
-ticket_iter_fin(void *cls)
+ticket_iter_fin (void *cls)
 {
   struct AttributeDeleteHandle *adh = cls;
 
   adh->ns_it = NULL;
-  GNUNET_SCHEDULER_add_now(&update_tickets, adh);
+  GNUNET_SCHEDULER_add_now (&update_tickets, adh);
 }
 
 
@@ -1190,16 +1204,16 @@ ticket_iter_fin(void *cls)
  * @param cls our attribute deletion handle
  */
 static void
-ticket_iter_err(void *cls)
+ticket_iter_err (void *cls)
 {
   struct AttributeDeleteHandle *adh = cls;
 
   adh->ns_it = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Namestore error on delete %s\n",
-             adh->label);
-  send_delete_response(adh, GNUNET_SYSERR);
-  cleanup_adh(adh);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Namestore error on delete %s\n",
+              adh->label);
+  send_delete_response (adh, GNUNET_SYSERR);
+  cleanup_adh (adh);
 }
 
 
@@ -1210,18 +1224,18 @@ ticket_iter_err(void *cls)
  * @param cls attribute deletion handle
  */
 static void
-start_ticket_update(void *cls)
+start_ticket_update (void *cls)
 {
   struct AttributeDeleteHandle *adh = cls;
 
-  adh->ns_it = GNUNET_NAMESTORE_zone_iteration_start(nsh,
-                                                     &adh->identity,
-                                                     &ticket_iter_err,
-                                                     adh,
-                                                     &ticket_iter,
-                                                     adh,
-                                                     &ticket_iter_fin,
-                                                     adh);
+  adh->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh,
+                                                      &adh->identity,
+                                                      &ticket_iter_err,
+                                                      adh,
+                                                      &ticket_iter,
+                                                      adh,
+                                                      &ticket_iter_fin,
+                                                      adh);
 }
 
 
@@ -1233,22 +1247,22 @@ start_ticket_update(void *cls)
  * @param emsg error message (NULL if success=GNUNET_OK)
  */
 static void
-attr_delete_cont(void *cls, int32_t success, const char *emsg)
+attr_delete_cont (void *cls, int32_t success, const char *emsg)
 {
   struct AttributeDeleteHandle *adh = cls;
 
   adh->ns_qe = NULL;
   if (GNUNET_SYSERR == success)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Error deleting attribute %s\n",
-                 adh->label);
-      send_delete_response(adh, GNUNET_SYSERR);
-      cleanup_adh(adh);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
-  GNUNET_SCHEDULER_add_now(&start_ticket_update, adh);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Error deleting attribute %s\n",
+                adh->label);
+    send_delete_response (adh, GNUNET_SYSERR);
+    cleanup_adh (adh);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
+  GNUNET_SCHEDULER_add_now (&start_ticket_update, adh);
 }
 
 
@@ -1259,17 +1273,17 @@ attr_delete_cont(void *cls, int32_t success, const char *emsg)
  * @dam message to check
  */
 static int
-check_attribute_delete_message(void *cls,
-                               const struct AttributeDeleteMessage *dam)
+check_attribute_delete_message (void *cls,
+                                const struct AttributeDeleteMessage *dam)
 {
   uint16_t size;
 
-  size = ntohs(dam->header.size);
+  size = ntohs (dam->header.size);
   if (size <= sizeof(struct AttributeDeleteMessage))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1281,34 +1295,35 @@ check_attribute_delete_message(void *cls,
  * @param dam deletion message
  */
 static void
-handle_attribute_delete_message(void *cls,
-                                const struct AttributeDeleteMessage *dam)
+handle_attribute_delete_message (void *cls,
+                                 const struct AttributeDeleteMessage *dam)
 {
   struct AttributeDeleteHandle *adh;
   struct IdpClient *idp = cls;
   size_t data_len;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
 
-  data_len = ntohs(dam->attr_len);
+  data_len = ntohs (dam->attr_len);
 
-  adh = GNUNET_new(struct AttributeDeleteHandle);
-  adh->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize((char *)&dam[1], data_len);
+  adh = GNUNET_new (struct AttributeDeleteHandle);
+  adh->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &dam[1],
+                                                     data_len);
 
-  adh->r_id = ntohl(dam->id);
+  adh->r_id = ntohl (dam->id);
   adh->identity = dam->identity;
   adh->label
-    = GNUNET_STRINGS_data_to_string_alloc(&adh->claim->id, sizeof(uint64_t));
-  GNUNET_SERVICE_client_continue(idp->client);
+    = GNUNET_STRINGS_data_to_string_alloc (&adh->claim->id, sizeof(uint64_t));
+  GNUNET_SERVICE_client_continue (idp->client);
   adh->client = idp;
-  GNUNET_CONTAINER_DLL_insert(idp->delete_op_head, idp->delete_op_tail, adh);
-  adh->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
-                                              &adh->identity,
-                                              adh->label,
-                                              0,
-                                              NULL,
-                                              &attr_delete_cont,
-                                              adh);
+  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
+  adh->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
+                                               &adh->identity,
+                                               adh->label,
+                                               0,
+                                               NULL,
+                                               &attr_delete_cont,
+                                               adh);
 }
 
 
@@ -1323,21 +1338,21 @@ handle_attribute_delete_message(void *cls,
  * @param cls our iterator handle
  */
 static void
-attr_iter_finished(void *cls)
+attr_iter_finished (void *cls)
 {
   struct AttributeIterator *ai = cls;
   struct GNUNET_MQ_Envelope *env;
   struct AttributeResultMessage *arm;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
-  env = GNUNET_MQ_msg(arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
-  arm->id = htonl(ai->request_id);
-  arm->attr_len = htons(0);
-  GNUNET_MQ_send(ai->client->mq, env);
-  GNUNET_CONTAINER_DLL_remove(ai->client->attr_iter_head,
-                              ai->client->attr_iter_tail,
-                              ai);
-  GNUNET_free(ai);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
+  env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
+  arm->id = htonl (ai->request_id);
+  arm->attr_len = htons (0);
+  GNUNET_MQ_send (ai->client->mq, env);
+  GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head,
+                               ai->client->attr_iter_tail,
+                               ai);
+  GNUNET_free (ai);
 }
 
 /**
@@ -1346,12 +1361,12 @@ attr_iter_finished(void *cls)
  * @param cls our attribute iteration handle
  */
 static void
-attr_iter_error(void *cls)
+attr_iter_error (void *cls)
 {
   struct AttributeIterator *ai = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
-  attr_iter_finished(ai);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
+  attr_iter_finished (ai);
 }
 
 
@@ -1365,11 +1380,11 @@ attr_iter_error(void *cls)
  * @param rd records
  */
 static void
-attr_iter_cb(void *cls,
-             const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-             const char *label,
-             unsigned int rd_count,
-             const struct GNUNET_GNSRECORD_Data *rd)
+attr_iter_cb (void *cls,
+              const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+              const char *label,
+              unsigned int rd_count,
+              const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct AttributeIterator *ai = cls;
   struct AttributeResultMessage *arm;
@@ -1377,27 +1392,27 @@ attr_iter_cb(void *cls,
   char *data_tmp;
 
   if (rd_count != 1)
-    {
-      GNUNET_NAMESTORE_zone_iterator_next(ai->ns_it, 1);
-      return;
-    }
+  {
+    GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
+    return;
+  }
 
   if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR != rd->record_type)
-    {
-      GNUNET_NAMESTORE_zone_iterator_next(ai->ns_it, 1);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n", label);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
-  env = GNUNET_MQ_msg_extra(arm,
-                            rd->data_size,
-                            GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
-  arm->id = htonl(ai->request_id);
-  arm->attr_len = htons(rd->data_size);
-  GNUNET_CRYPTO_ecdsa_key_get_public(zone, &arm->identity);
-  data_tmp = (char *)&arm[1];
-  GNUNET_memcpy(data_tmp, rd->data, rd->data_size);
-  GNUNET_MQ_send(ai->client->mq, env);
+  {
+    GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n", label);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
+  env = GNUNET_MQ_msg_extra (arm,
+                             rd->data_size,
+                             GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
+  arm->id = htonl (ai->request_id);
+  arm->attr_len = htons (rd->data_size);
+  GNUNET_CRYPTO_ecdsa_key_get_public (zone, &arm->identity);
+  data_tmp = (char *) &arm[1];
+  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
+  GNUNET_MQ_send (ai->client->mq, env);
 }
 
 
@@ -1408,29 +1423,29 @@ attr_iter_cb(void *cls,
  * @param ais_msg the iteration message to start
  */
 static void
-handle_iteration_start(void *cls,
-                       const struct AttributeIterationStartMessage *ais_msg)
+handle_iteration_start (void *cls,
+                        const struct AttributeIterationStartMessage *ais_msg)
 {
   struct IdpClient *idp = cls;
   struct AttributeIterator *ai;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received ATTRIBUTE_ITERATION_START message\n");
-  ai = GNUNET_new(struct AttributeIterator);
-  ai->request_id = ntohl(ais_msg->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ATTRIBUTE_ITERATION_START message\n");
+  ai = GNUNET_new (struct AttributeIterator);
+  ai->request_id = ntohl (ais_msg->id);
   ai->client = idp;
   ai->identity = ais_msg->identity;
 
-  GNUNET_CONTAINER_DLL_insert(idp->attr_iter_head, idp->attr_iter_tail, ai);
-  ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start(nsh,
-                                                    &ai->identity,
-                                                    &attr_iter_error,
-                                                    ai,
-                                                    &attr_iter_cb,
-                                                    ai,
-                                                    &attr_iter_finished,
-                                                    ai);
-  GNUNET_SERVICE_client_continue(idp->client);
+  GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai);
+  ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh,
+                                                     &ai->identity,
+                                                     &attr_iter_error,
+                                                     ai,
+                                                     &attr_iter_cb,
+                                                     ai,
+                                                     &attr_iter_finished,
+                                                     ai);
+  GNUNET_SERVICE_client_continue (idp->client);
 }
 
 
@@ -1441,29 +1456,29 @@ handle_iteration_start(void *cls,
  * @param ais_msg the stop message
  */
 static void
-handle_iteration_stop(void *cls,
-                      const struct AttributeIterationStopMessage *ais_msg)
+handle_iteration_stop (void *cls,
+                       const struct AttributeIterationStopMessage *ais_msg)
 {
   struct IdpClient *idp = cls;
   struct AttributeIterator *ai;
   uint32_t rid;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' message\n",
-             "ATTRIBUTE_ITERATION_STOP");
-  rid = ntohl(ais_msg->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "ATTRIBUTE_ITERATION_STOP");
+  rid = ntohl (ais_msg->id);
   for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
     if (ai->request_id == rid)
       break;
   if (NULL == ai)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(idp->client);
-      return;
-    }
-  GNUNET_CONTAINER_DLL_remove(idp->attr_iter_head, idp->attr_iter_tail, ai);
-  GNUNET_free(ai);
-  GNUNET_SERVICE_client_continue(idp->client);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (idp->client);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
+  GNUNET_free (ai);
+  GNUNET_SERVICE_client_continue (idp->client);
 }
 
 
@@ -1474,27 +1489,27 @@ handle_iteration_stop(void *cls,
  * @param ais_msg the message
  */
 static void
-handle_iteration_next(void *cls,
-                      const struct AttributeIterationNextMessage *ais_msg)
+handle_iteration_next (void *cls,
+                       const struct AttributeIterationNextMessage *ais_msg)
 {
   struct IdpClient *idp = cls;
   struct AttributeIterator *ai;
   uint32_t rid;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received ATTRIBUTE_ITERATION_NEXT message\n");
-  rid = ntohl(ais_msg->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ATTRIBUTE_ITERATION_NEXT message\n");
+  rid = ntohl (ais_msg->id);
   for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
     if (ai->request_id == rid)
       break;
   if (NULL == ai)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(idp->client);
-      return;
-    }
-  GNUNET_NAMESTORE_zone_iterator_next(ai->ns_it, 1);
-  GNUNET_SERVICE_client_continue(idp->client);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (idp->client);
+    return;
+  }
+  GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
+  GNUNET_SERVICE_client_continue (idp->client);
 }
 
 /******************************************************
@@ -1508,29 +1523,29 @@ handle_iteration_next(void *cls,
  * @param ticket the ticket
  */
 static void
-ticket_iter_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
+ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
 {
   struct TicketIteration *ti = cls;
   struct GNUNET_MQ_Envelope *env;
   struct TicketResultMessage *trm;
 
-  env = GNUNET_MQ_msg(trm, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT);
+  env = GNUNET_MQ_msg (trm, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT);
   if (NULL == ticket)
-    {
-      /* send empty response to indicate end of list */
-      GNUNET_CONTAINER_DLL_remove(ti->client->ticket_iter_head,
-                                  ti->client->ticket_iter_tail,
-                                  ti);
-    }
+  {
+    /* send empty response to indicate end of list */
+    GNUNET_CONTAINER_DLL_remove (ti->client->ticket_iter_head,
+                                 ti->client->ticket_iter_tail,
+                                 ti);
+  }
   else
-    {
-      trm->ticket = *ticket;
-    }
-  trm->id = htonl(ti->r_id);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
-  GNUNET_MQ_send(ti->client->mq, env);
+  {
+    trm->ticket = *ticket;
+  }
+  trm->id = htonl (ti->r_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
+  GNUNET_MQ_send (ti->client->mq, env);
   if (NULL == ticket)
-    GNUNET_free(ti);
+    GNUNET_free (ti);
 }
 
 
@@ -1541,25 +1556,25 @@ ticket_iter_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
  * @param tis_msg the iteration request message
  */
 static void
-handle_ticket_iteration_start(
+handle_ticket_iteration_start (
   void *cls,
   const struct TicketIterationStartMessage *tis_msg)
 {
   struct IdpClient *client = cls;
   struct TicketIteration *ti;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received TICKET_ITERATION_START message\n");
-  ti = GNUNET_new(struct TicketIteration);
-  ti->r_id = ntohl(tis_msg->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received TICKET_ITERATION_START message\n");
+  ti = GNUNET_new (struct TicketIteration);
+  ti->r_id = ntohl (tis_msg->id);
   ti->client = client;
 
-  GNUNET_CONTAINER_DLL_insert(client->ticket_iter_head,
-                              client->ticket_iter_tail,
-                              ti);
+  GNUNET_CONTAINER_DLL_insert (client->ticket_iter_head,
+                               client->ticket_iter_tail,
+                               ti);
   ti->iter
-    = RECLAIM_TICKETS_iteration_start(&tis_msg->identity, &ticket_iter_cb, ti);
-  GNUNET_SERVICE_client_continue(client->client);
+    = RECLAIM_TICKETS_iteration_start (&tis_msg->identity, &ticket_iter_cb, ti);
+  GNUNET_SERVICE_client_continue (client->client);
 }
 
 
@@ -1570,32 +1585,32 @@ handle_ticket_iteration_start(
  * @param tis_msg the stop message
  */
 static void
-handle_ticket_iteration_stop(void *cls,
-                             const struct TicketIterationStopMessage *tis_msg)
+handle_ticket_iteration_stop (void *cls,
+                              const struct TicketIterationStopMessage *tis_msg)
 {
   struct IdpClient *client = cls;
   struct TicketIteration *ti;
   uint32_t rid;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received `%s' message\n",
-             "TICKET_ITERATION_STOP");
-  rid = ntohl(tis_msg->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received `%s' message\n",
+              "TICKET_ITERATION_STOP");
+  rid = ntohl (tis_msg->id);
   for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
     if (ti->r_id == rid)
       break;
   if (NULL == ti)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(client->client);
-      return;
-    }
-  RECLAIM_TICKETS_iteration_stop(ti->iter);
-  GNUNET_CONTAINER_DLL_remove(client->ticket_iter_head,
-                              client->ticket_iter_tail,
-                              ti);
-  GNUNET_free(ti);
-  GNUNET_SERVICE_client_continue(client->client);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (client->client);
+    return;
+  }
+  RECLAIM_TICKETS_iteration_stop (ti->iter);
+  GNUNET_CONTAINER_DLL_remove (client->ticket_iter_head,
+                               client->ticket_iter_tail,
+                               ti);
+  GNUNET_free (ti);
+  GNUNET_SERVICE_client_continue (client->client);
 }
 
 
@@ -1606,27 +1621,27 @@ handle_ticket_iteration_stop(void *cls,
  * @param tis_msg the message
  */
 static void
-handle_ticket_iteration_next(void *cls,
-                             const struct TicketIterationNextMessage *tis_msg)
+handle_ticket_iteration_next (void *cls,
+                              const struct TicketIterationNextMessage *tis_msg)
 {
   struct IdpClient *client = cls;
   struct TicketIteration *ti;
   uint32_t rid;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received TICKET_ITERATION_NEXT message\n");
-  rid = ntohl(tis_msg->id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received TICKET_ITERATION_NEXT message\n");
+  rid = ntohl (tis_msg->id);
   for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
     if (ti->r_id == rid)
       break;
   if (NULL == ti)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(client->client);
-      return;
-    }
-  RECLAIM_TICKETS_iteration_next(ti->iter);
-  GNUNET_SERVICE_client_continue(client->client);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (client->client);
+    return;
+  }
+  RECLAIM_TICKETS_iteration_next (ti->iter);
+  GNUNET_SERVICE_client_continue (client->client);
 }
 
 
@@ -1638,28 +1653,28 @@ handle_ticket_iteration_next(void *cls,
  * @param server the service handle
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_SERVICE_Handle *server)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *server)
 {
   cfg = c;
 
-  if (GNUNET_OK != RECLAIM_TICKETS_init(cfg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Unable to initialize TICKETS subsystem.\n");
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  if (GNUNET_OK != RECLAIM_TICKETS_init (cfg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Unable to initialize TICKETS subsystem.\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   // Connect to identity and namestore services
-  nsh = GNUNET_NAMESTORE_connect(cfg);
+  nsh = GNUNET_NAMESTORE_connect (cfg);
   if (NULL == nsh)
-    {
-      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
-                          "error connecting to namestore");
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                         "error connecting to namestore");
+  }
 
-  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 }
 
 
@@ -1671,17 +1686,17 @@ run(void *cls,
  * @param app_ctx @a client
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
   struct IdpClient *idp = app_ctx;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
-  GNUNET_CONTAINER_DLL_remove(client_list_head,
-                              client_list_tail,
-                              idp);
-  cleanup_client(idp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
+  GNUNET_CONTAINER_DLL_remove (client_list_head,
+                               client_list_tail,
+                               idp);
+  cleanup_client (idp);
 }
 
 
@@ -1694,19 +1709,19 @@ client_disconnect_cb(void *cls,
  * @return internal namestore client structure for this client
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
   struct IdpClient *idp;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
-  idp = GNUNET_new(struct IdpClient);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
+  idp = GNUNET_new (struct IdpClient);
   idp->client = client;
   idp->mq = mq;
-  GNUNET_CONTAINER_DLL_insert(client_list_head,
-                              client_list_tail,
-                              idp);
+  GNUNET_CONTAINER_DLL_insert (client_list_head,
+                               client_list_tail,
+                               idp);
   return idp;
 }
 
@@ -1714,57 +1729,57 @@ client_connect_cb(void *cls,
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN(
+GNUNET_SERVICE_MAIN (
   "reclaim",
   GNUNET_SERVICE_OPTION_NONE,
   &run,
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_var_size(attribute_store_message,
-                        GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE,
-                        struct AttributeStoreMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(attribute_delete_message,
-                        GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE,
-                        struct AttributeDeleteMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(
+  GNUNET_MQ_hd_var_size (attribute_store_message,
+                         GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE,
+                         struct AttributeStoreMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (attribute_delete_message,
+                         GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE,
+                         struct AttributeDeleteMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (
     iteration_start,
     GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START,
     struct AttributeIterationStartMessage,
     NULL),
-  GNUNET_MQ_hd_fixed_size(iteration_next,
-                          GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT,
-                          struct AttributeIterationNextMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(iteration_stop,
-                          GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP,
-                          struct AttributeIterationStopMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(issue_ticket_message,
-                        GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET,
-                        struct IssueTicketMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(consume_ticket_message,
-                        GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET,
-                        struct ConsumeTicketMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(ticket_iteration_start,
-                          GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START,
-                          struct TicketIterationStartMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(ticket_iteration_next,
-                          GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT,
-                          struct TicketIterationNextMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(ticket_iteration_stop,
-                          GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP,
-                          struct TicketIterationStopMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(revoke_ticket_message,
-                        GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET,
-                        struct RevokeTicketMessage,
-                        NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_fixed_size (iteration_next,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT,
+                           struct AttributeIterationNextMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (iteration_stop,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP,
+                           struct AttributeIterationStopMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (issue_ticket_message,
+                         GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET,
+                         struct IssueTicketMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (consume_ticket_message,
+                         GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET,
+                         struct ConsumeTicketMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (ticket_iteration_start,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START,
+                           struct TicketIterationStartMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (ticket_iteration_next,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT,
+                           struct TicketIterationNextMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (ticket_iteration_stop,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP,
+                           struct TicketIterationStopMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (revoke_ticket_message,
+                         GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET,
+                         struct RevokeTicketMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
 /* end of gnunet-service-reclaim.c */