1 files changed, 584 insertions, 570 deletions

diff --git a/src/reclaim/gnunet-service-reclaim_tickets.c b/src/reclaim/gnunet-service-reclaim_tickets.c
index fcfb2267d..b38a5eb25 100644
--- a/src/reclaim/gnunet-service-reclaim_tickets.c
+++ b/src/reclaim/gnunet-service-reclaim_tickets.c
@@ -16,7 +16,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    SPDX-License-Identifier: AGPL3.0-or-later
-   */
+ */
 
 /**
  * @author Martin Schanzenbach
@@ -44,8 +44,7 @@ struct ParallelLookup;
 /**
  * A reference to a ticket stored in GNS
  */
-struct TicketReference
-{
+struct TicketReference {
   /**
    * DLL
    */
@@ -71,8 +70,7 @@ struct TicketReference
 /**
  * Handle to a consume operation
  */
-struct RECLAIM_TICKETS_ConsumeHandle
-{
+struct RECLAIM_TICKETS_ConsumeHandle {
   /**
    * Ticket
    */
@@ -133,8 +131,7 @@ struct RECLAIM_TICKETS_ConsumeHandle
 /**
  * Handle for a parallel GNS lookup job
  */
-struct ParallelLookup
-{
+struct ParallelLookup {
   /* DLL */
   struct ParallelLookup *next;
 
@@ -160,8 +157,7 @@ struct ParallelLookup
 /**
  * Ticket issue request handle
  */
-struct TicketIssueHandle
-{
+struct TicketIssueHandle {
   /**
    * Attributes to issue
    */
@@ -202,8 +198,7 @@ struct TicketIssueHandle
 /**
  * Ticket iterator
  */
-struct RECLAIM_TICKETS_Iterator
-{
+struct RECLAIM_TICKETS_Iterator {
   /**
    * Namestore queue entry
    */
@@ -221,8 +216,7 @@ struct RECLAIM_TICKETS_Iterator
 };
 
 
-struct RevokedAttributeEntry
-{
+struct RevokedAttributeEntry {
   /**
    * DLL
    */
@@ -248,8 +242,7 @@ struct RevokedAttributeEntry
 /**
  * Ticket revocation request handle
  */
-struct RECLAIM_TICKETS_RevokeHandle
-{
+struct RECLAIM_TICKETS_RevokeHandle {
   /**
    * Issuer Key
    */
@@ -337,31 +330,32 @@ static struct GNUNET_STATISTICS_Handle *stats;
  * @param rh the ticket revocation handle
  */
 static void
-cleanup_rvk (struct RECLAIM_TICKETS_RevokeHandle *rh)
+cleanup_rvk(struct RECLAIM_TICKETS_RevokeHandle *rh)
 {
   struct RevokedAttributeEntry *ae;
   struct TicketRecordsEntry *le;
+
   if (NULL != rh->ns_qe)
-    GNUNET_NAMESTORE_cancel (rh->ns_qe);
+    GNUNET_NAMESTORE_cancel(rh->ns_qe);
   if (NULL != rh->ns_it)
-    GNUNET_NAMESTORE_zone_iteration_stop (rh->ns_it);
+    GNUNET_NAMESTORE_zone_iteration_stop(rh->ns_it);
   while (NULL != (ae = rh->attrs_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (rh->attrs_head, rh->attrs_tail, ae);
-    GNUNET_free (ae);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(rh->attrs_head, rh->attrs_tail, ae);
+      GNUNET_free(ae);
+    }
   while (NULL != (le = rh->tickets_to_update_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (rh->tickets_to_update_head,
-                                 rh->tickets_to_update_head,
-                                 le);
-    if (NULL != le->data)
-      GNUNET_free (le->data);
-    if (NULL != le->label)
-      GNUNET_free (le->label);
-    GNUNET_free (le);
-  }
-  GNUNET_free (rh);
+    {
+      GNUNET_CONTAINER_DLL_remove(rh->tickets_to_update_head,
+                                  rh->tickets_to_update_head,
+                                  le);
+      if (NULL != le->data)
+        GNUNET_free(le->data);
+      if (NULL != le->label)
+        GNUNET_free(le->label);
+      GNUNET_free(le);
+    }
+  GNUNET_free(rh);
 }
 
 
@@ -372,7 +366,7 @@ cleanup_rvk (struct RECLAIM_TICKETS_RevokeHandle *rh)
  * @param cls handle to the operation
  */
 static void
-process_tickets (void *cls);
+process_tickets(void *cls);
 
 
 /**
@@ -384,11 +378,12 @@ process_tickets (void *cls);
  * @param emsg (NULL on success)
  */
 static void
-ticket_processed (void *cls, int32_t success, const char *emsg)
+ticket_processed(void *cls, int32_t success, const char *emsg)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
+
   rvk->ns_qe = NULL;
-  GNUNET_SCHEDULER_add_now (&process_tickets, rvk);
+  GNUNET_SCHEDULER_add_now(&process_tickets, rvk);
 }
 
 
@@ -398,56 +393,57 @@ ticket_processed (void *cls, int32_t success, const char *emsg)
  * @param cls handle to the operation
  */
 static void
-process_tickets (void *cls)
+process_tickets(void *cls)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
   struct TicketRecordsEntry *le;
   struct RevokedAttributeEntry *ae;
+
   if (NULL == rvk->tickets_to_update_head)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Finished updatding tickets, success\n");
-    rvk->cb (rvk->cb_cls, GNUNET_OK);
-    cleanup_rvk (rvk);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Finished updatding tickets, success\n");
+      rvk->cb(rvk->cb_cls, GNUNET_OK);
+      cleanup_rvk(rvk);
+      return;
+    }
   le = rvk->tickets_to_update_head;
-  GNUNET_CONTAINER_DLL_remove (rvk->tickets_to_update_head,
-                               rvk->tickets_to_update_tail,
-                               le);
+  GNUNET_CONTAINER_DLL_remove(rvk->tickets_to_update_head,
+                              rvk->tickets_to_update_tail,
+                              le);
   struct GNUNET_GNSRECORD_Data rd[le->rd_count];
-  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 ticket record(s)\n");
-    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-    cleanup_rvk (rvk);
-    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 ticket record(s)\n");
+      rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+      cleanup_rvk(rvk);
+      return;
+    }
   for (int i = 0; i < le->rd_count; i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
-      continue;
-    for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
     {
-      if (0 != memcmp (rd[i].data, &ae->old_id, sizeof (uint64_t)))
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
         continue;
-      rd[i].data = &ae->new_id;
+      for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
+        {
+          if (0 != memcmp(rd[i].data, &ae->old_id, sizeof(uint64_t)))
+            continue;
+          rd[i].data = &ae->new_id;
+        }
     }
-  }
-  rvk->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                               &rvk->identity,
-                                               le->label,
-                                               le->rd_count,
-                                               rd,
-                                               &ticket_processed,
-                                               rvk);
-  GNUNET_free (le->label);
-  GNUNET_free (le->data);
-  GNUNET_free (le);
+  rvk->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
+                                              &rvk->identity,
+                                              le->label,
+                                              le->rd_count,
+                                              rd,
+                                              &ticket_processed,
+                                              rvk);
+  GNUNET_free(le->label);
+  GNUNET_free(le->data);
+  GNUNET_free(le);
 }
 
 
@@ -457,11 +453,12 @@ process_tickets (void *cls)
  * @param cls handle to the operation
  */
 static void
-rvk_ticket_update_finished (void *cls)
+rvk_ticket_update_finished(void *cls)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
+
   rvk->ns_it = NULL;
-  GNUNET_SCHEDULER_add_now (&process_tickets, rvk);
+  GNUNET_SCHEDULER_add_now(&process_tickets, rvk);
 }
 
 
@@ -476,11 +473,11 @@ rvk_ticket_update_finished (void *cls)
  * @param rd record set
  */
 static void
-rvk_ticket_update (void *cls,
-                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                   const char *label,
-                   unsigned int rd_count,
-                   const struct GNUNET_GNSRECORD_Data *rd)
+rvk_ticket_update(void *cls,
+                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                  const char *label,
+                  unsigned int rd_count,
+                  const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
   struct TicketRecordsEntry *le;
@@ -489,32 +486,32 @@ rvk_ticket_update (void *cls,
 
   /** Let everything point to the old record **/
   for (int i = 0; i < rd_count; i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
-      continue;
-    for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
     {
-      if (0 != memcmp (rd[i].data, &ae->old_id, sizeof (uint64_t)))
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
         continue;
-      has_changed = GNUNET_YES;
-      break;
+      for (ae = rvk->attrs_head; NULL != ae; ae = ae->next)
+        {
+          if (0 != memcmp(rd[i].data, &ae->old_id, sizeof(uint64_t)))
+            continue;
+          has_changed = GNUNET_YES;
+          break;
+        }
+      if (GNUNET_YES == has_changed)
+        break;
     }
-    if (GNUNET_YES == has_changed)
-      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 (rvk->tickets_to_update_head,
-                                 rvk->tickets_to_update_tail,
-                                 le);
-  }
-  GNUNET_NAMESTORE_zone_iterator_next (rvk->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(rvk->tickets_to_update_head,
+                                  rvk->tickets_to_update_tail,
+                                  le);
+    }
+  GNUNET_NAMESTORE_zone_iterator_next(rvk->ns_it, 1);
 }
 
 
@@ -524,15 +521,16 @@ rvk_ticket_update (void *cls,
  * @param cls handle to the operation
  */
 static void
-rvk_ns_iter_err (void *cls)
+rvk_ns_iter_err(void *cls)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
+
   rvk->ns_it = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Namestore error on revocation (id=%" PRIu64 "\n",
-              rvk->move_attr->old_id);
-  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-  cleanup_rvk (rvk);
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             "Namestore error on revocation (id=%" PRIu64 "\n",
+             rvk->move_attr->old_id);
+  rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+  cleanup_rvk(rvk);
 }
 
 
@@ -542,15 +540,16 @@ rvk_ns_iter_err (void *cls)
  * @param cls handle to the operation
  */
 static void
-rvk_ns_err (void *cls)
+rvk_ns_err(void *cls)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
+
   rvk->ns_qe = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Namestore error on revocation (id=%" PRIu64 "\n",
-              rvk->move_attr->old_id);
-  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-  cleanup_rvk (rvk);
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             "Namestore error on revocation (id=%" PRIu64 "\n",
+             rvk->move_attr->old_id);
+  rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+  cleanup_rvk(rvk);
 }
 
 
@@ -564,7 +563,7 @@ rvk_ns_err (void *cls)
  * @param rvk handle to the operation
  */
 static void
-move_attrs (struct RECLAIM_TICKETS_RevokeHandle *rh);
+move_attrs(struct RECLAIM_TICKETS_RevokeHandle *rh);
 
 
 /**
@@ -573,9 +572,9 @@ move_attrs (struct RECLAIM_TICKETS_RevokeHandle *rh);
  * @param cls handle to the operation.
  */
 static void
-move_attrs_cont (void *cls)
+move_attrs_cont(void *cls)
 {
-  move_attrs ((struct RECLAIM_TICKETS_RevokeHandle *) cls);
+  move_attrs((struct RECLAIM_TICKETS_RevokeHandle *)cls);
 }
 
 
@@ -588,21 +587,22 @@ move_attrs_cont (void *cls)
  * @param emsg error message (NULL on success)
  */
 static void
-del_attr_finished (void *cls, int32_t success, const char *emsg)
+del_attr_finished(void *cls, int32_t success, const char *emsg)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
+
   rvk->ns_qe = NULL;
   if (GNUNET_SYSERR == success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Error removing attribute: %s\n",
-                emsg);
-    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-    cleanup_rvk (rvk);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Error removing attribute: %s\n",
+                 emsg);
+      rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+      cleanup_rvk(rvk);
+      return;
+    }
   rvk->move_attr = rvk->move_attr->next;
-  GNUNET_SCHEDULER_add_now (&move_attrs_cont, rvk);
+  GNUNET_SCHEDULER_add_now(&move_attrs_cont, rvk);
 }
 
 
@@ -616,30 +616,31 @@ del_attr_finished (void *cls, int32_t success, const char *emsg)
  * @param emsg error message (NULL on success)
  */
 static void
-move_attr_finished (void *cls, int32_t success, const char *emsg)
+move_attr_finished(void *cls, int32_t success, const char *emsg)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
   char *label;
+
   rvk->ns_qe = NULL;
   if (GNUNET_SYSERR == success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error moving attribute: %s\n", emsg);
-    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-    cleanup_rvk (rvk);
-    return;
-  }
-  label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->old_id,
-                                               sizeof (uint64_t));
-  GNUNET_assert (NULL != label);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Removing attribute %s\n", label);
-  rvk->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                               &rvk->identity,
-                                               label,
-                                               0,
-                                               NULL,
-                                               &del_attr_finished,
-                                               rvk);
-  GNUNET_free (label);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error moving attribute: %s\n", emsg);
+      rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+      cleanup_rvk(rvk);
+      return;
+    }
+  label = GNUNET_STRINGS_data_to_string_alloc(&rvk->move_attr->old_id,
+                                              sizeof(uint64_t));
+  GNUNET_assert(NULL != label);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Removing attribute %s\n", label);
+  rvk->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
+                                              &rvk->identity,
+                                              label,
+                                              0,
+                                              NULL,
+                                              &del_attr_finished,
+                                              rvk);
+  GNUNET_free(label);
 }
 
 
@@ -653,11 +654,11 @@ move_attr_finished (void *cls, int32_t success, const char *emsg)
  * @param rd record set (the attribute)
  */
 static void
-rvk_move_attr_cb (void *cls,
-                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                  const char *label,
-                  unsigned int rd_count,
-                  const struct GNUNET_GNSRECORD_Data *rd)
+rvk_move_attr_cb(void *cls,
+                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                 const char *label,
+                 unsigned int rd_count,
+                 const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
   struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
@@ -665,46 +666,47 @@ rvk_move_attr_cb (void *cls,
   struct RevokedAttributeEntry *le;
   char *new_label;
   char *attr_data;
+
   rvk->ns_qe = NULL;
   if (0 == rd_count)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "The attribute %s no longer exists!\n",
-                label);
-    le = rvk->move_attr;
-    rvk->move_attr = le->next;
-    GNUNET_CONTAINER_DLL_remove (rvk->attrs_head, rvk->attrs_tail, le);
-    GNUNET_free (le);
-    GNUNET_SCHEDULER_add_now (&move_attrs_cont, rvk);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "The attribute %s no longer exists!\n",
+                 label);
+      le = rvk->move_attr;
+      rvk->move_attr = le->next;
+      GNUNET_CONTAINER_DLL_remove(rvk->attrs_head, rvk->attrs_tail, le);
+      GNUNET_free(le);
+      GNUNET_SCHEDULER_add_now(&move_attrs_cont, rvk);
+      return;
+    }
   /** find a new place for this attribute **/
   rvk->move_attr->new_id =
-    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
+    GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
   new_rd = *rd;
-  claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize (rd->data, rd->data_size);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Attribute to update: Name=%s, ID=%" PRIu64 "\n",
-              claim->name,
-              claim->id);
+  claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize(rd->data, rd->data_size);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Attribute to update: Name=%s, ID=%" PRIu64 "\n",
+             claim->name,
+             claim->id);
   claim->id = rvk->move_attr->new_id;
-  new_rd.data_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (claim);
-  attr_data = GNUNET_malloc (rd->data_size);
-  new_rd.data_size = GNUNET_RECLAIM_ATTRIBUTE_serialize (claim, attr_data);
+  new_rd.data_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size(claim);
+  attr_data = GNUNET_malloc(rd->data_size);
+  new_rd.data_size = GNUNET_RECLAIM_ATTRIBUTE_serialize(claim, attr_data);
   new_rd.data = attr_data;
-  new_label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->new_id,
-                                                   sizeof (uint64_t));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute %s\n", new_label);
-  rvk->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                               &rvk->identity,
-                                               new_label,
-                                               1,
-                                               &new_rd,
-                                               &move_attr_finished,
-                                               rvk);
-  GNUNET_free (new_label);
-  GNUNET_free (claim);
-  GNUNET_free (attr_data);
+  new_label = GNUNET_STRINGS_data_to_string_alloc(&rvk->move_attr->new_id,
+                                                  sizeof(uint64_t));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding attribute %s\n", new_label);
+  rvk->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
+                                              &rvk->identity,
+                                              new_label,
+                                              1,
+                                              &new_rd,
+                                              &move_attr_finished,
+                                              rvk);
+  GNUNET_free(new_label);
+  GNUNET_free(claim);
+  GNUNET_free(attr_data);
 }
 
 
@@ -717,36 +719,36 @@ rvk_move_attr_cb (void *cls,
  * @param rvk handle to the operation
  */
 static void
-move_attrs (struct RECLAIM_TICKETS_RevokeHandle *rvk)
+move_attrs(struct RECLAIM_TICKETS_RevokeHandle *rvk)
 {
   char *label;
 
   if (NULL == rvk->move_attr)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished moving attributes\n");
-    rvk->ns_it =
-      GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                             &rvk->identity,
-                                             &rvk_ns_iter_err,
-                                             rvk,
-                                             &rvk_ticket_update,
-                                             rvk,
-                                             &rvk_ticket_update_finished,
-                                             rvk);
-    return;
-  }
-  label = GNUNET_STRINGS_data_to_string_alloc (&rvk->move_attr->old_id,
-                                               sizeof (uint64_t));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Moving attribute %s\n", label);
-
-  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
-                                                &rvk->identity,
-                                                label,
-                                                &rvk_ns_err,
-                                                rvk,
-                                                &rvk_move_attr_cb,
-                                                rvk);
-  GNUNET_free (label);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Finished moving attributes\n");
+      rvk->ns_it =
+        GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                              &rvk->identity,
+                                              &rvk_ns_iter_err,
+                                              rvk,
+                                              &rvk_ticket_update,
+                                              rvk,
+                                              &rvk_ticket_update_finished,
+                                              rvk);
+      return;
+    }
+  label = GNUNET_STRINGS_data_to_string_alloc(&rvk->move_attr->old_id,
+                                              sizeof(uint64_t));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Moving attribute %s\n", label);
+
+  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup(nsh,
+                                               &rvk->identity,
+                                               label,
+                                               &rvk_ns_err,
+                                               rvk,
+                                               &rvk_move_attr_cb,
+                                               rvk);
+  GNUNET_free(label);
 }
 
 
@@ -762,28 +764,29 @@ move_attrs (struct RECLAIM_TICKETS_RevokeHandle *rvk)
  * @param emsg error message (NULL on success)
  */
 static void
-remove_ticket_cont (void *cls, int32_t success, const char *emsg)
+remove_ticket_cont(void *cls, int32_t success, const char *emsg)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
+
   rvk->ns_qe = NULL;
   if (GNUNET_SYSERR == success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
-    rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-    cleanup_rvk (rvk);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleted ticket\n");
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "%s\n", emsg);
+      rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+      cleanup_rvk(rvk);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Deleted ticket\n");
   if (0 == rvk->ticket_attrs)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "No attributes to move... strange\n");
-    rvk->cb (rvk->cb_cls, GNUNET_OK);
-    cleanup_rvk (rvk);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                 "No attributes to move... strange\n");
+      rvk->cb(rvk->cb_cls, GNUNET_OK);
+      cleanup_rvk(rvk);
+      return;
+    }
   rvk->move_attr = rvk->attrs_head;
-  move_attrs (rvk);
+  move_attrs(rvk);
 }
 
 
@@ -798,38 +801,39 @@ remove_ticket_cont (void *cls, int32_t success, const char *emsg)
  * @param rd record set
  */
 static void
-revoke_attrs_cb (void *cls,
-                 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                 const char *label,
-                 unsigned int rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+revoke_attrs_cb(void *cls,
+                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                const char *label,
+                unsigned int rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
   struct RevokedAttributeEntry *le;
+
   rvk->ns_qe = NULL;
   /**
    * Temporarily store attribute references.
    * We need it later.
    */
   for (int i = 0; i < rd_count; i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
-      continue;
-    le = GNUNET_new (struct RevokedAttributeEntry);
-    le->old_id = *((uint64_t *) rd[i].data);
-    GNUNET_CONTAINER_DLL_insert (rvk->attrs_head, rvk->attrs_tail, le);
-    rvk->ticket_attrs++;
-  }
+    {
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
+        continue;
+      le = GNUNET_new(struct RevokedAttributeEntry);
+      le->old_id = *((uint64_t *)rd[i].data);
+      GNUNET_CONTAINER_DLL_insert(rvk->attrs_head, rvk->attrs_tail, le);
+      rvk->ticket_attrs++;
+    }
 
   /** Remove attribute references **/
-  rvk->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                               &rvk->identity,
-                                               label,
-                                               0,
-                                               NULL,
-                                               &remove_ticket_cont,
-                                               rvk);
+  rvk->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
+                                              &rvk->identity,
+                                              label,
+                                              0,
+                                              NULL,
+                                              &remove_ticket_cont,
+                                              rvk);
 }
 
 
@@ -839,11 +843,12 @@ revoke_attrs_cb (void *cls,
  * @param cls handle to the operation
  */
 static void
-rvk_attrs_err_cb (void *cls)
+rvk_attrs_err_cb(void *cls)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk = cls;
-  rvk->cb (rvk->cb_cls, GNUNET_SYSERR);
-  cleanup_rvk (rvk);
+
+  rvk->cb(rvk->cb_cls, GNUNET_SYSERR);
+  cleanup_rvk(rvk);
 }
 
 
@@ -859,31 +864,31 @@ rvk_attrs_err_cb (void *cls)
  * @return handle to the operation
  */
 struct RECLAIM_TICKETS_RevokeHandle *
-RECLAIM_TICKETS_revoke (const struct GNUNET_RECLAIM_Ticket *ticket,
-                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
-                        RECLAIM_TICKETS_RevokeCallback cb,
-                        void *cb_cls)
+RECLAIM_TICKETS_revoke(const struct GNUNET_RECLAIM_Ticket *ticket,
+                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
+                       RECLAIM_TICKETS_RevokeCallback cb,
+                       void *cb_cls)
 {
   struct RECLAIM_TICKETS_RevokeHandle *rvk;
   char *label;
 
-  rvk = GNUNET_new (struct RECLAIM_TICKETS_RevokeHandle);
+  rvk = GNUNET_new(struct RECLAIM_TICKETS_RevokeHandle);
   rvk->cb = cb;
   rvk->cb_cls = cb_cls;
   rvk->identity = *identity;
   rvk->ticket = *ticket;
-  GNUNET_CRYPTO_ecdsa_key_get_public (&rvk->identity, &rvk->ticket.identity);
+  GNUNET_CRYPTO_ecdsa_key_get_public(&rvk->identity, &rvk->ticket.identity);
   /** Get shared attributes **/
-  label = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t));
-  GNUNET_assert (NULL != label);
-  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
-                                                identity,
-                                                label,
-                                                &rvk_attrs_err_cb,
-                                                rvk,
-                                                &revoke_attrs_cb,
-                                                rvk);
-  GNUNET_free (label);
+  label = GNUNET_STRINGS_data_to_string_alloc(&ticket->rnd, sizeof(uint64_t));
+  GNUNET_assert(NULL != label);
+  rvk->ns_qe = GNUNET_NAMESTORE_records_lookup(nsh,
+                                               identity,
+                                               label,
+                                               &rvk_attrs_err_cb,
+                                               rvk,
+                                               &revoke_attrs_cb,
+                                               rvk);
+  GNUNET_free(label);
   return rvk;
 }
 
@@ -894,16 +899,16 @@ RECLAIM_TICKETS_revoke (const struct GNUNET_RECLAIM_Ticket *ticket,
  * @param rh handle to the operation
  */
 void
-RECLAIM_TICKETS_revoke_cancel (struct RECLAIM_TICKETS_RevokeHandle *rh)
+RECLAIM_TICKETS_revoke_cancel(struct RECLAIM_TICKETS_RevokeHandle *rh)
 {
-  GNUNET_assert (NULL != rh);
-  cleanup_rvk (rh);
+  GNUNET_assert(NULL != rh);
+  cleanup_rvk(rh);
 }
 
 
 /*******************************
- * Ticket consume
- *******************************/
+* Ticket consume
+*******************************/
 
 /**
  * Cleanup ticket consume handle
@@ -911,27 +916,28 @@ RECLAIM_TICKETS_revoke_cancel (struct RECLAIM_TICKETS_RevokeHandle *rh)
  * @param cth the handle to clean up
  */
 static void
-cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth)
+cleanup_cth(struct RECLAIM_TICKETS_ConsumeHandle *cth)
 {
   struct ParallelLookup *lu;
+
   if (NULL != cth->lookup_request)
-    GNUNET_GNS_lookup_cancel (cth->lookup_request);
+    GNUNET_GNS_lookup_cancel(cth->lookup_request);
   if (NULL != cth->kill_task)
-    GNUNET_SCHEDULER_cancel (cth->kill_task);
+    GNUNET_SCHEDULER_cancel(cth->kill_task);
   while (NULL != (lu = cth->parallel_lookups_head))
-  {
-    if (NULL != lu->lookup_request)
-      GNUNET_GNS_lookup_cancel (lu->lookup_request);
-    GNUNET_free_non_null (lu->label);
-    GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head,
-                                 cth->parallel_lookups_tail,
-                                 lu);
-    GNUNET_free (lu);
-  }
+    {
+      if (NULL != lu->lookup_request)
+        GNUNET_GNS_lookup_cancel(lu->lookup_request);
+      GNUNET_free_non_null(lu->label);
+      GNUNET_CONTAINER_DLL_remove(cth->parallel_lookups_head,
+                                  cth->parallel_lookups_tail,
+                                  lu);
+      GNUNET_free(lu);
+    }
 
   if (NULL != cth->attrs)
-    GNUNET_RECLAIM_ATTRIBUTE_list_destroy (cth->attrs);
-  GNUNET_free (cth);
+    GNUNET_RECLAIM_ATTRIBUTE_list_destroy(cth->attrs);
+  GNUNET_free(cth);
 }
 
 
@@ -943,50 +949,51 @@ cleanup_cth (struct RECLAIM_TICKETS_ConsumeHandle *cth)
  * @param rd record set
  */
 static void
-process_parallel_lookup_result (void *cls,
-                                uint32_t rd_count,
-                                const struct GNUNET_GNSRECORD_Data *rd)
+process_parallel_lookup_result(void *cls,
+                               uint32_t rd_count,
+                               const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ParallelLookup *parallel_lookup = cls;
   struct RECLAIM_TICKETS_ConsumeHandle *cth = parallel_lookup->handle;
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *attr_le;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Parallel lookup finished (count=%u)\n",
-              rd_count);
 
-  GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head,
-                               cth->parallel_lookups_tail,
-                               parallel_lookup);
-  GNUNET_free (parallel_lookup->label);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Parallel lookup finished (count=%u)\n",
+             rd_count);
+
+  GNUNET_CONTAINER_DLL_remove(cth->parallel_lookups_head,
+                              cth->parallel_lookups_tail,
+                              parallel_lookup);
+  GNUNET_free(parallel_lookup->label);
 
-  GNUNET_STATISTICS_update (stats,
-                            "attribute_lookup_time_total",
-                            GNUNET_TIME_absolute_get_duration (
-                              parallel_lookup->lookup_start_time)
-                              .rel_value_us,
-                            GNUNET_YES);
-  GNUNET_STATISTICS_update (stats, "attribute_lookups_count", 1, GNUNET_YES);
+  GNUNET_STATISTICS_update(stats,
+                           "attribute_lookup_time_total",
+                           GNUNET_TIME_absolute_get_duration(
+                             parallel_lookup->lookup_start_time)
+                           .rel_value_us,
+                           GNUNET_YES);
+  GNUNET_STATISTICS_update(stats, "attribute_lookups_count", 1, GNUNET_YES);
 
 
-  GNUNET_free (parallel_lookup);
+  GNUNET_free(parallel_lookup);
   if (1 != rd_count)
-    GNUNET_break (0); // FIXME: We should never find this.
+    GNUNET_break(0);  // FIXME: We should never find this.
   if (rd->record_type == GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR)
-  {
-    attr_le = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry);
-    attr_le->claim =
-      GNUNET_RECLAIM_ATTRIBUTE_deserialize (rd->data, rd->data_size);
-    GNUNET_CONTAINER_DLL_insert (cth->attrs->list_head,
-                                 cth->attrs->list_tail,
-                                 attr_le);
-  }
+    {
+      attr_le = GNUNET_new(struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry);
+      attr_le->claim =
+        GNUNET_RECLAIM_ATTRIBUTE_deserialize(rd->data, rd->data_size);
+      GNUNET_CONTAINER_DLL_insert(cth->attrs->list_head,
+                                  cth->attrs->list_tail,
+                                  attr_le);
+    }
 
   if (NULL != cth->parallel_lookups_head)
     return; // Wait for more
 
   /* Else we are done */
-  cth->cb (cth->cb_cls, &cth->ticket.identity, cth->attrs, GNUNET_OK, NULL);
-  cleanup_cth (cth);
+  cth->cb(cth->cb_cls, &cth->ticket.identity, cth->attrs, GNUNET_OK, NULL);
+  cleanup_cth(cth);
 }
 
 
@@ -996,7 +1003,7 @@ process_parallel_lookup_result (void *cls,
  * @param cls handle to the operation
  */
 static void
-abort_parallel_lookups (void *cls)
+abort_parallel_lookups(void *cls)
 {
   struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
   struct ParallelLookup *lu;
@@ -1004,17 +1011,17 @@ abort_parallel_lookups (void *cls)
 
   cth->kill_task = NULL;
   for (lu = cth->parallel_lookups_head; NULL != lu;)
-  {
-    GNUNET_GNS_lookup_cancel (lu->lookup_request);
-    GNUNET_free (lu->label);
-    tmp = lu->next;
-    GNUNET_CONTAINER_DLL_remove (cth->parallel_lookups_head,
-                                 cth->parallel_lookups_tail,
-                                 lu);
-    GNUNET_free (lu);
-    lu = tmp;
-  }
-  cth->cb (cth->cb_cls, NULL, NULL, GNUNET_SYSERR, "Aborted");
+    {
+      GNUNET_GNS_lookup_cancel(lu->lookup_request);
+      GNUNET_free(lu->label);
+      tmp = lu->next;
+      GNUNET_CONTAINER_DLL_remove(cth->parallel_lookups_head,
+                                  cth->parallel_lookups_tail,
+                                  lu);
+      GNUNET_free(lu);
+      lu = tmp;
+    }
+  cth->cb(cth->cb_cls, NULL, NULL, GNUNET_SYSERR, "Aborted");
 }
 
 
@@ -1028,9 +1035,9 @@ abort_parallel_lookups (void *cls)
  * @param rd record set
  */
 static void
-lookup_authz_cb (void *cls,
-                 uint32_t rd_count,
-                 const struct GNUNET_GNSRECORD_Data *rd)
+lookup_authz_cb(void *cls,
+                uint32_t rd_count,
+                const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RECLAIM_TICKETS_ConsumeHandle *cth = cls;
   struct ParallelLookup *parallel_lookup;
@@ -1038,56 +1045,56 @@ lookup_authz_cb (void *cls,
 
   cth->lookup_request = NULL;
 
-  GNUNET_STATISTICS_update (stats,
-                            "reclaim_authz_lookup_time_total",
-                            GNUNET_TIME_absolute_get_duration (
-                              cth->lookup_start_time)
-                              .rel_value_us,
-                            GNUNET_YES);
-  GNUNET_STATISTICS_update (stats,
-                            "reclaim_authz_lookups_count",
-                            1,
-                            GNUNET_YES);
+  GNUNET_STATISTICS_update(stats,
+                           "reclaim_authz_lookup_time_total",
+                           GNUNET_TIME_absolute_get_duration(
+                             cth->lookup_start_time)
+                           .rel_value_us,
+                           GNUNET_YES);
+  GNUNET_STATISTICS_update(stats,
+                           "reclaim_authz_lookups_count",
+                           1,
+                           GNUNET_YES);
 
   for (int i = 0; i < rd_count; i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
-      continue;
-    lbl = GNUNET_STRINGS_data_to_string_alloc (rd[i].data, rd[i].data_size);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Attribute ref found %s\n", lbl);
-    parallel_lookup = GNUNET_new (struct ParallelLookup);
-    parallel_lookup->handle = cth;
-    parallel_lookup->label = lbl;
-    parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get ();
-    parallel_lookup->lookup_request =
-      GNUNET_GNS_lookup (gns,
-                         lbl,
-                         &cth->ticket.identity,
-                         GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR,
-                         GNUNET_GNS_LO_DEFAULT,
-                         &process_parallel_lookup_result,
-                         parallel_lookup);
-    GNUNET_CONTAINER_DLL_insert (cth->parallel_lookups_head,
-                                 cth->parallel_lookups_tail,
-                                 parallel_lookup);
-  }
+    {
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
+        continue;
+      lbl = GNUNET_STRINGS_data_to_string_alloc(rd[i].data, rd[i].data_size);
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Attribute ref found %s\n", lbl);
+      parallel_lookup = GNUNET_new(struct ParallelLookup);
+      parallel_lookup->handle = cth;
+      parallel_lookup->label = lbl;
+      parallel_lookup->lookup_start_time = GNUNET_TIME_absolute_get();
+      parallel_lookup->lookup_request =
+        GNUNET_GNS_lookup(gns,
+                          lbl,
+                          &cth->ticket.identity,
+                          GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR,
+                          GNUNET_GNS_LO_DEFAULT,
+                          &process_parallel_lookup_result,
+                          parallel_lookup);
+      GNUNET_CONTAINER_DLL_insert(cth->parallel_lookups_head,
+                                  cth->parallel_lookups_tail,
+                                  parallel_lookup);
+    }
   /**
    * We started lookups. Add a timeout task.
    * FIXME: Really needed here?
    */
   if (NULL != cth->parallel_lookups_head)
-  {
-    cth->kill_task = GNUNET_SCHEDULER_add_delayed (
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 3),
-      &abort_parallel_lookups,
-      cth);
-    return;
-  }
+    {
+      cth->kill_task = GNUNET_SCHEDULER_add_delayed(
+        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 3),
+        &abort_parallel_lookups,
+        cth);
+      return;
+    }
   /**
    * No references found, return empty attribute list
    */
-  cth->cb (cth->cb_cls, &cth->ticket.identity, cth->attrs, GNUNET_OK, NULL);
-  cleanup_cth (cth);
+  cth->cb(cth->cb_cls, &cth->ticket.identity, cth->attrs, GNUNET_OK, NULL);
+  cleanup_cth(cth);
 }
 
 
@@ -1103,36 +1110,37 @@ lookup_authz_cb (void *cls,
  * @return handle to the operation
  */
 struct RECLAIM_TICKETS_ConsumeHandle *
-RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_EcdsaPrivateKey *id,
-                         const struct GNUNET_RECLAIM_Ticket *ticket,
-                         RECLAIM_TICKETS_ConsumeCallback cb,
-                         void *cb_cls)
+RECLAIM_TICKETS_consume(const struct GNUNET_CRYPTO_EcdsaPrivateKey *id,
+                        const struct GNUNET_RECLAIM_Ticket *ticket,
+                        RECLAIM_TICKETS_ConsumeCallback cb,
+                        void *cb_cls)
 {
   struct RECLAIM_TICKETS_ConsumeHandle *cth;
   char *label;
-  cth = GNUNET_new (struct RECLAIM_TICKETS_ConsumeHandle);
+
+  cth = GNUNET_new(struct RECLAIM_TICKETS_ConsumeHandle);
 
   cth->identity = *id;
-  GNUNET_CRYPTO_ecdsa_key_get_public (&cth->identity, &cth->identity_pub);
-  cth->attrs = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList);
+  GNUNET_CRYPTO_ecdsa_key_get_public(&cth->identity, &cth->identity_pub);
+  cth->attrs = GNUNET_new(struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList);
   cth->ticket = *ticket;
   cth->cb = cb;
   cth->cb_cls = cb_cls;
   label =
-    GNUNET_STRINGS_data_to_string_alloc (&cth->ticket.rnd, sizeof (uint64_t));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Looking for AuthZ info under %s\n",
-              label);
-  cth->lookup_start_time = GNUNET_TIME_absolute_get ();
+    GNUNET_STRINGS_data_to_string_alloc(&cth->ticket.rnd, sizeof(uint64_t));
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Looking for AuthZ info under %s\n",
+             label);
+  cth->lookup_start_time = GNUNET_TIME_absolute_get();
   cth->lookup_request =
-    GNUNET_GNS_lookup (gns,
-                       label,
-                       &cth->ticket.identity,
-                       GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF,
-                       GNUNET_GNS_LO_DEFAULT,
-                       &lookup_authz_cb,
-                       cth);
-  GNUNET_free (label);
+    GNUNET_GNS_lookup(gns,
+                      label,
+                      &cth->ticket.identity,
+                      GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF,
+                      GNUNET_GNS_LO_DEFAULT,
+                      &lookup_authz_cb,
+                      cth);
+  GNUNET_free(label);
   return cth;
 }
 
@@ -1143,27 +1151,27 @@ RECLAIM_TICKETS_consume (const struct GNUNET_CRYPTO_EcdsaPrivateKey *id,
  * @param cth the operation to cancel
  */
 void
-RECLAIM_TICKETS_consume_cancel (struct RECLAIM_TICKETS_ConsumeHandle *cth)
+RECLAIM_TICKETS_consume_cancel(struct RECLAIM_TICKETS_ConsumeHandle *cth)
 {
-  cleanup_cth (cth);
+  cleanup_cth(cth);
   return;
 }
 
 
 /*******************************
- * Ticket issue
- *******************************/
+* Ticket issue
+*******************************/
 
 /**
  * Cleanup ticket consume handle
  * @param handle the handle to clean up
  */
 static void
-cleanup_issue_handle (struct TicketIssueHandle *handle)
+cleanup_issue_handle(struct TicketIssueHandle *handle)
 {
   if (NULL != handle->ns_qe)
-    GNUNET_NAMESTORE_cancel (handle->ns_qe);
-  GNUNET_free (handle);
+    GNUNET_NAMESTORE_cancel(handle->ns_qe);
+  GNUNET_free(handle);
 }
 
 
@@ -1176,21 +1184,21 @@ cleanup_issue_handle (struct TicketIssueHandle *handle)
  * @param emsg error message (or NULL on success)
  */
 static void
-store_ticket_issue_cont (void *cls, int32_t success, const char *emsg)
+store_ticket_issue_cont(void *cls, int32_t success, const char *emsg)
 {
   struct TicketIssueHandle *handle = cls;
 
   handle->ns_qe = NULL;
   if (GNUNET_SYSERR == success)
-  {
-    handle->cb (handle->cb_cls,
-                &handle->ticket,
-                GNUNET_SYSERR,
-                "Error storing AuthZ ticket in GNS");
-    return;
-  }
-  handle->cb (handle->cb_cls, &handle->ticket, GNUNET_OK, NULL);
-  cleanup_issue_handle (handle);
+    {
+      handle->cb(handle->cb_cls,
+                 &handle->ticket,
+                 GNUNET_SYSERR,
+                 "Error storing AuthZ ticket in GNS");
+      return;
+    }
+  handle->cb(handle->cb_cls, &handle->ticket, GNUNET_OK, NULL);
+  cleanup_issue_handle(handle);
 }
 
 
@@ -1202,7 +1210,7 @@ store_ticket_issue_cont (void *cls, int32_t success, const char *emsg)
  * @param ih handle to the operation containing relevant metadata
  */
 static void
-issue_ticket (struct TicketIssueHandle *ih)
+issue_ticket(struct TicketIssueHandle *ih)
 {
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
   struct GNUNET_GNSRECORD_Data *attrs_record;
@@ -1214,45 +1222,45 @@ issue_ticket (struct TicketIssueHandle *ih)
     list_len++;
 
   attrs_record =
-    GNUNET_malloc (list_len * sizeof (struct GNUNET_GNSRECORD_Data));
+    GNUNET_malloc(list_len * sizeof(struct GNUNET_GNSRECORD_Data));
   i = 0;
   for (le = ih->attrs->list_head; NULL != le; le = le->next)
-  {
-    attrs_record[i].data = &le->claim->id;
-    attrs_record[i].data_size = sizeof (le->claim->id);
-    /**
-     * FIXME: Should this be the attribute expiration time or ticket
-     * refresh interval? Probably min(attrs.expiration)
-     */
-    attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us;
-    attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF;
-    attrs_record[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-    i++;
-  }
+    {
+      attrs_record[i].data = &le->claim->id;
+      attrs_record[i].data_size = sizeof(le->claim->id);
+      /**
+       * FIXME: Should this be the attribute expiration time or ticket
+       * refresh interval? Probably min(attrs.expiration)
+       */
+      attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us;
+      attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF;
+      attrs_record[i].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
+      i++;
+    }
   attrs_record[i].data = &ih->ticket;
-  attrs_record[i].data_size = sizeof (struct GNUNET_RECLAIM_Ticket);
+  attrs_record[i].data_size = sizeof(struct GNUNET_RECLAIM_Ticket);
   attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us;
   attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET;
   attrs_record[i].flags =
     GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION | GNUNET_GNSRECORD_RF_PRIVATE;
 
   label =
-    GNUNET_STRINGS_data_to_string_alloc (&ih->ticket.rnd, sizeof (uint64_t));
+    GNUNET_STRINGS_data_to_string_alloc(&ih->ticket.rnd, sizeof(uint64_t));
   // Publish record
-  ih->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                              &ih->identity,
-                                              label,
-                                              list_len,
-                                              attrs_record,
-                                              &store_ticket_issue_cont,
-                                              ih);
-  GNUNET_free (attrs_record);
-  GNUNET_free (label);
+  ih->ns_qe = GNUNET_NAMESTORE_records_store(nsh,
+                                             &ih->identity,
+                                             label,
+                                             list_len,
+                                             attrs_record,
+                                             &store_ticket_issue_cont,
+                                             ih);
+  GNUNET_free(attrs_record);
+  GNUNET_free(label);
 }
 
 /*************************************************
- * Ticket iteration (finding a specific ticket)
- *************************************************/
+* Ticket iteration (finding a specific ticket)
+*************************************************/
 
 
 /**
@@ -1261,15 +1269,16 @@ issue_ticket (struct TicketIssueHandle *ih)
  * @param cls handle to the operation
  */
 static void
-filter_tickets_error_cb (void *cls)
+filter_tickets_error_cb(void *cls)
 {
   struct TicketIssueHandle *tih = cls;
+
   tih->ns_it = NULL;
-  tih->cb (tih->cb_cls,
-           &tih->ticket,
-           GNUNET_SYSERR,
-           "Error storing AuthZ ticket in GNS");
-  cleanup_issue_handle (tih);
+  tih->cb(tih->cb_cls,
+          &tih->ticket,
+          GNUNET_SYSERR,
+          "Error storing AuthZ ticket in GNS");
+  cleanup_issue_handle(tih);
 }
 
 
@@ -1286,11 +1295,11 @@ filter_tickets_error_cb (void *cls)
  * @param rd record set
  */
 static void
-filter_tickets_cb (void *cls,
-                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                   const char *label,
-                   unsigned int rd_count,
-                   const struct GNUNET_GNSRECORD_Data *rd)
+filter_tickets_cb(void *cls,
+                  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                  const char *label,
+                  unsigned int rd_count,
+                  const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct TicketIssueHandle *tih = cls;
   struct GNUNET_RECLAIM_Ticket *ticket = NULL;
@@ -1298,6 +1307,7 @@ filter_tickets_cb (void *cls,
   // figure out the number of requested attributes
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
   unsigned int attr_cnt = 0;
+
   for (le = tih->attrs->list_head; NULL != le; le = le->next)
     attr_cnt++;
 
@@ -1305,53 +1315,53 @@ filter_tickets_cb (void *cls,
   unsigned int found_attrs_cnt = 0;
 
   for (int i = 0; i < rd_count; i++)
-  {
-    // found ticket
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type)
     {
-      ticket = (struct GNUNET_RECLAIM_Ticket *) rd[i].data;
-      // cmp audience
-      if (0 == memcmp (&tih->ticket.audience,
-                       &ticket->audience,
-                       sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
-      {
-        tih->ticket = *ticket;
+      // found ticket
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type)
+        {
+          ticket = (struct GNUNET_RECLAIM_Ticket *)rd[i].data;
+          // cmp audience
+          if (0 == memcmp(&tih->ticket.audience,
+                          &ticket->audience,
+                          sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
+            {
+              tih->ticket = *ticket;
+              continue;
+            }
+          ticket = NULL;
+        }
+
+      // cmp requested attributes with ticket attributes
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
         continue;
-      }
-      ticket = NULL;
-    }
-
-    // cmp requested attributes with ticket attributes
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
-      continue;
-    for (le = tih->attrs->list_head; NULL != le; le = le->next)
-    {
-      // cmp attr_ref id with requested attr id
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  " %" PRIu64 "\n  %" PRIu64 "\n",
-                  *((uint64_t *) rd[i].data),
-                  le->claim->id);
-
-
-      if (0 == memcmp (rd[i].data, &le->claim->id, sizeof (uint64_t)))
-        found_attrs_cnt++;
+      for (le = tih->attrs->list_head; NULL != le; le = le->next)
+        {
+          // cmp attr_ref id with requested attr id
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                     " %" PRIu64 "\n  %" PRIu64 "\n",
+                     *((uint64_t *)rd[i].data),
+                     le->claim->id);
+
+
+          if (0 == memcmp(rd[i].data, &le->claim->id, sizeof(uint64_t)))
+            found_attrs_cnt++;
+        }
     }
-  }
 
   /**
    * If we found a matching ticket, return that to the caller and
    * we are done.
    */
   if (attr_cnt == found_attrs_cnt && NULL != ticket)
-  {
-    GNUNET_NAMESTORE_zone_iteration_stop (tih->ns_it);
-    tih->cb (tih->cb_cls, &tih->ticket, GNUNET_OK, NULL);
-    cleanup_issue_handle (tih);
-    return;
-  }
+    {
+      GNUNET_NAMESTORE_zone_iteration_stop(tih->ns_it);
+      tih->cb(tih->cb_cls, &tih->ticket, GNUNET_OK, NULL);
+      cleanup_issue_handle(tih);
+      return;
+    }
 
   // ticket not found in current record, checking next record set
-  GNUNET_NAMESTORE_zone_iterator_next (tih->ns_it, 1);
+  GNUNET_NAMESTORE_zone_iterator_next(tih->ns_it, 1);
 }
 
 
@@ -1363,13 +1373,14 @@ filter_tickets_cb (void *cls,
  * @param cls handle to the operation
  */
 static void
-filter_tickets_finished_cb (void *cls)
+filter_tickets_finished_cb(void *cls)
 {
   struct TicketIssueHandle *tih = cls;
-  GNUNET_CRYPTO_ecdsa_key_get_public (&tih->identity, &tih->ticket.identity);
+
+  GNUNET_CRYPTO_ecdsa_key_get_public(&tih->identity, &tih->ticket.identity);
   tih->ticket.rnd =
-    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
-  issue_ticket (tih);
+    GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
+  issue_ticket(tih);
 }
 
 
@@ -1385,36 +1396,37 @@ filter_tickets_finished_cb (void *cls)
  * FIXME: Return handle??
  */
 void
-RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
-                       const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
-                       const struct GNUNET_CRYPTO_EcdsaPublicKey *audience,
-                       RECLAIM_TICKETS_TicketResult cb,
-                       void *cb_cls)
+RECLAIM_TICKETS_issue(const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
+                      const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
+                      const struct GNUNET_CRYPTO_EcdsaPublicKey *audience,
+                      RECLAIM_TICKETS_TicketResult cb,
+                      void *cb_cls)
 {
   struct TicketIssueHandle *tih;
-  tih = GNUNET_new (struct TicketIssueHandle);
+
+  tih = GNUNET_new(struct TicketIssueHandle);
   tih->cb = cb;
   tih->cb_cls = cb_cls;
-  tih->attrs = GNUNET_RECLAIM_ATTRIBUTE_list_dup (attrs);
+  tih->attrs = GNUNET_RECLAIM_ATTRIBUTE_list_dup(attrs);
   tih->identity = *identity;
   tih->ticket.audience = *audience;
 
   // First check whether the ticket has already been issued
   tih->ns_it =
-    GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                           &tih->identity,
-                                           &filter_tickets_error_cb,
-                                           tih,
-                                           &filter_tickets_cb,
-                                           tih,
-                                           &filter_tickets_finished_cb,
-                                           tih);
+    GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                          &tih->identity,
+                                          &filter_tickets_error_cb,
+                                          tih,
+                                          &filter_tickets_cb,
+                                          tih,
+                                          &filter_tickets_finished_cb,
+                                          tih);
 }
 
 
 /************************************
- * Ticket iteration
- ************************************/
+* Ticket iteration
+************************************/
 
 /**
  * Cleanup ticket iterator
@@ -1422,11 +1434,11 @@ RECLAIM_TICKETS_issue (const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
  * @param iter handle to the iteration
  */
 static void
-cleanup_iter (struct RECLAIM_TICKETS_Iterator *iter)
+cleanup_iter(struct RECLAIM_TICKETS_Iterator *iter)
 {
   if (NULL != iter->ns_it)
-    GNUNET_NAMESTORE_zone_iteration_stop (iter->ns_it);
-  GNUNET_free (iter);
+    GNUNET_NAMESTORE_zone_iteration_stop(iter->ns_it);
+  GNUNET_free(iter);
 }
 
 
@@ -1442,22 +1454,22 @@ cleanup_iter (struct RECLAIM_TICKETS_Iterator *iter)
  * @param rd record set containing a ticket
  */
 static void
-collect_tickets_cb (void *cls,
-                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-                    const char *label,
-                    unsigned int rd_count,
-                    const struct GNUNET_GNSRECORD_Data *rd)
+collect_tickets_cb(void *cls,
+                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+                   const char *label,
+                   unsigned int rd_count,
+                   const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct RECLAIM_TICKETS_Iterator *iter = cls;
 
   for (int i = 0; i < rd_count; i++)
-  {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type)
-      continue;
-    iter->cb (iter->cb_cls, (struct GNUNET_RECLAIM_Ticket *) rd[i].data);
-    return;
-  }
-  GNUNET_NAMESTORE_zone_iterator_next (iter->ns_it, 1);
+    {
+      if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type)
+        continue;
+      iter->cb(iter->cb_cls, (struct GNUNET_RECLAIM_Ticket *)rd[i].data);
+      return;
+    }
+  GNUNET_NAMESTORE_zone_iterator_next(iter->ns_it, 1);
 }
 
 
@@ -1467,12 +1479,13 @@ collect_tickets_cb (void *cls,
  * @param cls handle to the iteration
  */
 static void
-collect_tickets_finished_cb (void *cls)
+collect_tickets_finished_cb(void *cls)
 {
   struct RECLAIM_TICKETS_Iterator *iter = cls;
+
   iter->ns_it = NULL;
-  iter->cb (iter->cb_cls, NULL);
-  cleanup_iter (iter);
+  iter->cb(iter->cb_cls, NULL);
+  cleanup_iter(iter);
 }
 
 
@@ -1482,12 +1495,13 @@ collect_tickets_finished_cb (void *cls)
  * @param cls the iteration handle
  */
 static void
-collect_tickets_error_cb (void *cls)
+collect_tickets_error_cb(void *cls)
 {
   struct RECLAIM_TICKETS_Iterator *iter = cls;
+
   iter->ns_it = NULL;
-  iter->cb (iter->cb_cls, NULL);
-  cleanup_iter (iter);
+  iter->cb(iter->cb_cls, NULL);
+  cleanup_iter(iter);
 }
 
 
@@ -1497,9 +1511,9 @@ collect_tickets_error_cb (void *cls)
  * @param iter the iteration to continue
  */
 void
-RECLAIM_TICKETS_iteration_next (struct RECLAIM_TICKETS_Iterator *iter)
+RECLAIM_TICKETS_iteration_next(struct RECLAIM_TICKETS_Iterator *iter)
 {
-  GNUNET_NAMESTORE_zone_iterator_next (iter->ns_it, 1);
+  GNUNET_NAMESTORE_zone_iterator_next(iter->ns_it, 1);
 }
 
 
@@ -1509,10 +1523,10 @@ RECLAIM_TICKETS_iteration_next (struct RECLAIM_TICKETS_Iterator *iter)
  * @param iter iteration to cancel
  */
 void
-RECLAIM_TICKETS_iteration_stop (struct RECLAIM_TICKETS_Iterator *iter)
+RECLAIM_TICKETS_iteration_stop(struct RECLAIM_TICKETS_Iterator *iter)
 {
-  GNUNET_NAMESTORE_zone_iteration_stop (iter->ns_it);
-  cleanup_iter (iter);
+  GNUNET_NAMESTORE_zone_iteration_stop(iter->ns_it);
+  cleanup_iter(iter);
 }
 
 
@@ -1525,25 +1539,25 @@ RECLAIM_TICKETS_iteration_stop (struct RECLAIM_TICKETS_Iterator *iter)
  * @return a handle to the iteration
  */
 struct RECLAIM_TICKETS_Iterator *
-RECLAIM_TICKETS_iteration_start (
+RECLAIM_TICKETS_iteration_start(
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity,
   RECLAIM_TICKETS_TicketIter cb,
   void *cb_cls)
 {
   struct RECLAIM_TICKETS_Iterator *iter;
 
-  iter = GNUNET_new (struct RECLAIM_TICKETS_Iterator);
+  iter = GNUNET_new(struct RECLAIM_TICKETS_Iterator);
   iter->cb = cb;
   iter->cb_cls = cb_cls;
   iter->ns_it =
-    GNUNET_NAMESTORE_zone_iteration_start (nsh,
-                                           identity,
-                                           &collect_tickets_error_cb,
-                                           iter,
-                                           &collect_tickets_cb,
-                                           iter,
-                                           &collect_tickets_finished_cb,
-                                           iter);
+    GNUNET_NAMESTORE_zone_iteration_start(nsh,
+                                          identity,
+                                          &collect_tickets_error_cb,
+                                          iter,
+                                          &collect_tickets_cb,
+                                          iter,
+                                          &collect_tickets_finished_cb,
+                                          iter);
   return iter;
 }
 
@@ -1555,39 +1569,39 @@ RECLAIM_TICKETS_iteration_start (
  * @return GNUNET_SYSERR on error
  */
 int
-RECLAIM_TICKETS_init (const struct GNUNET_CONFIGURATION_Handle *c)
+RECLAIM_TICKETS_init(const struct GNUNET_CONFIGURATION_Handle *c)
 {
   // Get ticket expiration time (relative) from config
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_time (c,
-                                           "reclaim",
-                                           "TICKET_REFRESH_INTERVAL",
-                                           &ticket_refresh_interval))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Configured refresh interval for tickets: %s\n",
-                GNUNET_STRINGS_relative_time_to_string (ticket_refresh_interval,
+      GNUNET_CONFIGURATION_get_value_time(c,
+                                          "reclaim",
+                                          "TICKET_REFRESH_INTERVAL",
+                                          &ticket_refresh_interval))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Configured refresh interval for tickets: %s\n",
+                 GNUNET_STRINGS_relative_time_to_string(ticket_refresh_interval,
                                                         GNUNET_YES));
-  }
+    }
   else
-  {
-    ticket_refresh_interval = DEFAULT_TICKET_REFRESH_INTERVAL;
-  }
+    {
+      ticket_refresh_interval = DEFAULT_TICKET_REFRESH_INTERVAL;
+    }
   // Connect to identity and namestore services
-  nsh = GNUNET_NAMESTORE_connect (c);
+  nsh = GNUNET_NAMESTORE_connect(c);
   if (NULL == nsh)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                         "error connecting to namestore");
-    return GNUNET_SYSERR;
-  }
-  gns = GNUNET_GNS_connect (c);
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
+                          "error connecting to namestore");
+      return GNUNET_SYSERR;
+    }
+  gns = GNUNET_GNS_connect(c);
   if (NULL == gns)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "error connecting to gns");
-    return GNUNET_SYSERR;
-  }
-  stats = GNUNET_STATISTICS_create ("reclaim", c);
+    {
+      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "error connecting to gns");
+      return GNUNET_SYSERR;
+    }
+  stats = GNUNET_STATISTICS_create("reclaim", c);
   return GNUNET_OK;
 }
 
@@ -1597,17 +1611,17 @@ RECLAIM_TICKETS_init (const struct GNUNET_CONFIGURATION_Handle *c)
  * FIXME: cancel all pending operations (gns, ns etc)
  */
 void
-RECLAIM_TICKETS_deinit (void)
+RECLAIM_TICKETS_deinit(void)
 {
   if (NULL != nsh)
-    GNUNET_NAMESTORE_disconnect (nsh);
+    GNUNET_NAMESTORE_disconnect(nsh);
   nsh = NULL;
   if (NULL != gns)
-    GNUNET_GNS_disconnect (gns);
+    GNUNET_GNS_disconnect(gns);
   gns = NULL;
   if (NULL != stats)
-  {
-    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-    stats = NULL;
-  }
+    {
+      GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
+      stats = NULL;
+    }
 }