1 files changed, 323 insertions, 632 deletions

diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c
index 556006af0..d4d44c3fc 100644
--- a/src/reclaim/gnunet-service-reclaim.c
+++ b/src/reclaim/gnunet-service-reclaim.c
@@ -29,7 +29,7 @@
 #include "gnunet_constants.h"
 #include "gnunet_gnsrecord_lib.h"
 #include "gnunet_protocols.h"
-#include "gnunet_reclaim_attribute_lib.h"
+#include "gnunet_reclaim_lib.h"
 #include "gnunet_reclaim_service.h"
 #include "gnunet_signatures.h"
 #include "reclaim.h"
@@ -90,17 +90,17 @@ struct TicketIteration
 /**
  * An attribute iteration operation.
  */
-struct AttributeIterator
+struct Iterator
 {
   /**
    * Next element in the DLL
    */
-  struct AttributeIterator *next;
+  struct Iterator *next;
 
   /**
    * Previous element in the DLL
    */
-  struct AttributeIterator *prev;
+  struct Iterator *prev;
 
   /**
    * IDP client which intiated this zone iteration
@@ -121,6 +121,11 @@ struct AttributeIterator
    * The operation id fot the zone iteration in the response for the client
    */
   uint32_t request_id;
+
+  /**
+   * Context
+   */
+  void *ctx;
 };
 
 
@@ -154,14 +159,28 @@ struct IdpClient
    * Attribute iteration operations in
    * progress initiated by this client
    */
-  struct AttributeIterator *attr_iter_head;
+  struct Iterator *attr_iter_head;
+
+  /**
+   * Tail of the DLL of
+   * Attribute iteration operations
+   * in progress initiated by this client
+   */
+  struct Iterator *attr_iter_tail;
+
+  /**
+   * Head of the DLL of
+   * Attribute iteration operations in
+   * progress initiated by this client
+   */
+  struct Iterator *attest_iter_head;
 
   /**
    * Tail of the DLL of
    * Attribute iteration operations
    * in progress initiated by this client
    */
-  struct AttributeIterator *attr_iter_tail;
+  struct Iterator *attest_iter_tail;
 
   /**
    * Head of DLL of ticket iteration ops
@@ -263,18 +282,14 @@ struct AttributeDeleteHandle
   /**
    * The attribute to delete
    */
-  struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
+  struct GNUNET_RECLAIM_Attribute *claim;
 
   /**
    * The attestation to delete
    */
-  struct GNUNET_RECLAIM_ATTESTATION_Claim *attest;
+  struct GNUNET_RECLAIM_Attestation *attest;
 
   /**
-  * The reference to delete
-  */
-  struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *reference;
-  /**
    * Tickets to update
    */
   struct TicketRecordsEntry *tickets_to_update_head;
@@ -334,17 +349,12 @@ struct AttributeStoreHandle
   /**
    * The attribute to store
    */
-  struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
+  struct GNUNET_RECLAIM_Attribute *claim;
 
   /**
   * The attestation to store
   */
-  struct GNUNET_RECLAIM_ATTESTATION_Claim *attest;
-
-  /**
-  * The reference to store
-  */
-  struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *reference;
+  struct GNUNET_RECLAIM_Attestation *attest;
 
   /**
    * The attribute expiration interval
@@ -480,8 +490,6 @@ cleanup_adh (struct AttributeDeleteHandle *adh)
     GNUNET_free (adh->claim);
   if (NULL != adh->attest)
     GNUNET_free (adh->attest);
-  if (NULL != adh->reference)
-    GNUNET_free (adh->reference);
   while (NULL != (le = adh->tickets_to_update_head))
   {
     GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head,
@@ -511,8 +519,6 @@ cleanup_as_handle (struct AttributeStoreHandle *ash)
     GNUNET_free (ash->claim);
   if (NULL != ash->attest)
     GNUNET_free (ash->attest);
-  if (NULL != ash->reference)
-    GNUNET_free (ash->reference);
   GNUNET_free (ash);
 }
 
@@ -525,7 +531,7 @@ cleanup_as_handle (struct AttributeStoreHandle *ash)
 static void
 cleanup_client (struct IdpClient *idp)
 {
-  struct AttributeIterator *ai;
+  struct Iterator *ai;
   struct TicketIteration *ti;
   struct TicketRevocationOperation *rop;
   struct TicketIssueOperation *iss;
@@ -563,6 +569,13 @@ cleanup_client (struct IdpClient *idp)
     GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
     GNUNET_free (ai);
   }
+  while (NULL != (ai = idp->attest_iter_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (idp->attest_iter_head, idp->attest_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);
@@ -718,13 +731,13 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
 {
   struct TicketIssueOperation *tio;
   struct IdpClient *idp = cls;
-  struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs;
+  struct GNUNET_RECLAIM_AttributeList *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 = GNUNET_RECLAIM_attribute_list_deserialize ((char *) &im[1],
                                                      attrs_len);
   tio->r_id = ntohl (im->id);
   tio->client = idp;
@@ -735,7 +748,7 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
                          &issue_ticket_result_cb,
                          tio);
   GNUNET_SERVICE_client_continue (idp->client);
-  GNUNET_RECLAIM_ATTRIBUTE_list_destroy (attrs);
+  GNUNET_RECLAIM_attribute_list_destroy (attrs);
 }
 
 
@@ -828,7 +841,8 @@ handle_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *rm)
 static void
 consume_result_cb (void *cls,
                    const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-                   const struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attrs,
+                   const struct GNUNET_RECLAIM_AttributeList *attrs,
+                   const struct GNUNET_RECLAIM_AttestationList *attests,
                    int32_t success,
                    const char *emsg)
 {
@@ -837,23 +851,28 @@ consume_result_cb (void *cls,
   struct GNUNET_MQ_Envelope *env;
   char *data_tmp;
   size_t attrs_len;
+  size_t attests_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);
+  attrs_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs);
+  attests_len = GNUNET_RECLAIM_attestation_list_serialize_get_size (attests);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending CONSUME_TICKET_RESULT message\n");
   env = GNUNET_MQ_msg_extra (crm,
-                             attrs_len,
+                             attrs_len + attests_len,
                              GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT);
   crm->id = htonl (cop->r_id);
   crm->attrs_len = htons (attrs_len);
+  crm->attestations_len = htons (attests_len);
   crm->identity = *identity;
   crm->result = htonl (success);
   data_tmp = (char *) &crm[1];
-  GNUNET_RECLAIM_ATTRIBUTE_list_serialize (attrs, data_tmp);
+  GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp);
+  data_tmp += attrs_len;
+  GNUNET_RECLAIM_attestation_list_serialize (attests, data_tmp);
   GNUNET_MQ_send (cop->client->mq, env);
   GNUNET_CONTAINER_DLL_remove (cop->client->consume_op_head,
                                cop->client->consume_op_tail,
@@ -965,20 +984,20 @@ attr_store_task (void *cls)
   size_t buf_size;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
-  buf_size = GNUNET_RECLAIM_ATTRIBUTE_serialize_get_size (ash->claim);
+  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);
+  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->claim->id))
+    GNUNET_RECLAIM_id_generate (&ash->claim->id);
+  GNUNET_RECLAIM_attribute_serialize (ash->claim, buf);
   label
-    = GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id, sizeof(uint64_t));
+    = GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id,
+                                           sizeof (ash->claim->id));
   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].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE;
   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,
@@ -1034,7 +1053,7 @@ handle_attribute_store_message (void *cls,
   data_len = ntohs (sam->attr_len);
 
   ash = GNUNET_new (struct AttributeStoreHandle);
-  ash->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &sam[1],
+  ash->claim = GNUNET_RECLAIM_attribute_deserialize ((char *) &sam[1],
                                                      data_len);
 
   ash->r_id = ntohl (sam->id);
@@ -1086,30 +1105,6 @@ attest_store_cont (void *cls, int32_t success, const char *emsg)
   cleanup_as_handle (ash);
 }
 
-/**
-     * Send a reference error response
-     *
-     * @param ash our attribute store handle
-     * @param success the success status
-     */
-static void
-send_ref_error (struct AttributeStoreHandle  *ash)
-{
-  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_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_SYSERR);
-  GNUNET_MQ_send (ash->client->mq, env);
-  cleanup_as_handle (ash);
-}
 
 /**
  * Error looking up potential attestation. Abort.
@@ -1127,8 +1122,9 @@ attest_error (void *cls)
   return;
 }
 
+
 /**
-* Check for existing record before storing reference
+* Check for existing record before storing attestation
 *
 * @param cls our attribute store handle
 * @param zone zone we are iterating
@@ -1146,58 +1142,30 @@ attest_add_cb (void *cls,
   struct AttributeStoreHandle *ash = cls;
   char *buf;
   size_t buf_size;
-  buf_size = GNUNET_RECLAIM_ATTESTATION_serialize_get_size (ash->attest);
+  buf_size = GNUNET_RECLAIM_attestation_serialize_get_size (ash->attest);
   buf = GNUNET_malloc (buf_size);
-  GNUNET_RECLAIM_ATTESTATION_serialize (ash->attest, buf);
-  if (0 == rd_count )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Storing new Attestation\n");
-    struct GNUNET_GNSRECORD_Data rd_new[1];
-    rd_new[0].data_size = buf_size;
-    rd_new[0].data = buf;
-    rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR;
-    rd_new[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-    rd_new[0].expiration_time = ash->exp.rel_value_us;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
-    ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                                 &ash->identity,
-                                                 label,
-                                                 1,
-                                                 rd_new,
-                                                 &attest_store_cont,
-                                                 ash);
-    GNUNET_free (buf);
-    return;
-  }
-  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR != rd[0].record_type)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Existing Attestation location is not an Attestation\n");
-    send_ref_error (ash);
-    return;
-  }
-  struct GNUNET_GNSRECORD_Data rd_new[rd_count];
-  for (int i = 0; i<rd_count; i++)
-  {
-    rd_new[i] = rd[i];
-  }
+  GNUNET_RECLAIM_attestation_serialize (ash->attest, buf);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Storing new Attestation\n");
+  struct GNUNET_GNSRECORD_Data rd_new[1];
   rd_new[0].data_size = buf_size;
   rd_new[0].data = buf;
-  rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR;
+  rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION;
   rd_new[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
   rd_new[0].expiration_time = ash->exp.rel_value_us;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
   ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
                                                &ash->identity,
                                                label,
-                                               rd_count,
+                                               1,
                                                rd_new,
                                                &attest_store_cont,
                                                ash);
   GNUNET_free (buf);
+  return;
 }
 
+
 /**
  * Add a new attestation
  *
@@ -1210,11 +1178,10 @@ attest_store_task (void *cls)
   char *label;
 
   // Give the ash a new id if unset
-  if (0 == ash->attest->id)
-    ash->attest->id
-      = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
+  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->attest->id))
+    GNUNET_RECLAIM_id_generate (&ash->attest->id);
   label = GNUNET_STRINGS_data_to_string_alloc (&ash->attest->id,
-                                               sizeof(uint64_t));
+                                               sizeof (ash->attest->id));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Looking up existing data under label %s\n", label);
 // Test for the content of the existing ID
@@ -1228,6 +1195,7 @@ attest_store_task (void *cls)
   GNUNET_free (label);
 }
 
+
 /**
  * Check an attestation store message
  *
@@ -1249,6 +1217,7 @@ check_attestation_store_message (void *cls,
   return GNUNET_OK;
 }
 
+
 /**
 * Handle an attestation store message
 *
@@ -1268,7 +1237,7 @@ handle_attestation_store_message (void *cls,
   data_len = ntohs (sam->attr_len);
 
   ash = GNUNET_new (struct AttributeStoreHandle);
-  ash->attest = GNUNET_RECLAIM_ATTESTATION_deserialize ((char *) &sam[1],
+  ash->attest = GNUNET_RECLAIM_attestation_deserialize ((char *) &sam[1],
                                                         data_len);
 
   ash->r_id = ntohl (sam->id);
@@ -1282,246 +1251,8 @@ handle_attestation_store_message (void *cls,
   GNUNET_SCHEDULER_add_now (&attest_store_task, ash);
 }
 
-/**
- * Error looking up potential reference value. Abort.
- *
- * @param cls our attribute store handle
- */
-static void
-ref_error (void *cls)
-{
-  struct AttributeStoreHandle *ash = cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Failed to find Attestation entry for Attestation reference\n");
-  cleanup_as_handle (ash);
-  GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
-  return;
-}
-
-/**
- * Error looking up potential reference value. Abort.
- *
- * @param cls our attribute delete handle
- */
-static void
-ref_del_error (void *cls)
-{
-  struct AttributeDeleteHandle *adh = cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Failed to find Attestation entry for Attestation reference\n");
-  cleanup_adh (adh);
-  GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
-  return;
-}
-/**
-* Reference store result handler
-*
-* @param cls our attribute store handle
-* @param success GNUNET_OK if successful
-* @param emsg error message (NULL if success=GNUNET_OK)
-*/
-static void
-reference_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);
-
-  if (GNUNET_SYSERR == success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to store reference %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);
-}
-
 
 /**
-* Check for existing record before storing reference
-*
-* @param cls our attribute store handle
-* @param zone zone we are iterating
-* @param label label of the records
-* @param rd_count record count
-* @param rd records
-*/
-static void
-ref_add_cb (void *cls,
-            const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-            const char *label,
-            unsigned int rd_count,
-            const struct GNUNET_GNSRECORD_Data *rd)
-{
-  struct AttributeStoreHandle *ash = cls;
-  char *buf;
-  size_t buf_size;
-  buf_size = GNUNET_RECLAIM_ATTESTATION_REF_serialize_get_size (ash->reference);
-  buf = GNUNET_malloc (buf_size);
-  GNUNET_RECLAIM_ATTESTATION_REF_serialize (ash->reference, buf);
-  struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *ref;
-  char *data_tmp;
-  if (0 == rd_count )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to find Attestation entry for Attestation reference\n");
-    send_ref_error (ash);
-    return;
-  }
-  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR != rd[0].record_type)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Intended Reference storage location is not an attestation\n");
-    send_ref_error (ash);
-    return;
-  }
-  struct GNUNET_GNSRECORD_Data rd_new[rd_count + 1];
-  int i;
-  for (i = 0; i<rd_count; i++)
-  {
-    data_tmp = GNUNET_malloc (rd[i].data_size);
-    GNUNET_memcpy (data_tmp, rd[i].data, rd[i].data_size);
-    ref = GNUNET_RECLAIM_ATTESTATION_REF_deserialize (data_tmp, htons (
-                                                        rd[i].data_size));
-    rd_new[i] = rd[i];
-    if ((strcmp (ash->reference->name,ref->name) == 0)&&
-        (strcmp (ash->reference->reference_value,ref->reference_value)==0) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Reference already stored\n");
-      reference_store_cont (ash,GNUNET_OK, NULL);
-      return;
-    }
-  }
-  rd_new[rd_count].data_size = buf_size;
-  rd_new[rd_count].data = buf;
-  rd_new[rd_count].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_REFERENCE;
-  rd_new[rd_count].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
-  rd_new[rd_count].expiration_time = ash->exp.rel_value_us;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
-  ash->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                               &ash->identity,
-                                               label,
-                                               rd_count + 1,
-                                               rd_new,
-                                               &reference_store_cont,
-                                               ash);
-  GNUNET_free (buf);
-}
-
-/**
- * Add a new reference
- *
- * @param cls the AttributeStoreHandle
- */
-static void
-reference_store_task (void *cls)
-{
-  struct AttributeStoreHandle *ash = cls;
-  char *label;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing reference\n");
-
-  // Give the ash a new id if unset
-  if (0 == ash->reference->id)
-  {
-    if (0 == ash->reference->id_attest)
-    {
-      ash->reference->id = GNUNET_CRYPTO_random_u64 (
-        GNUNET_CRYPTO_QUALITY_STRONG,
-        UINT64_MAX);
-    }
-    else
-    {
-      ash->reference->id = ash->reference->id_attest;
-    }
-  }
-
-  label = GNUNET_STRINGS_data_to_string_alloc (&ash->reference->id,
-                                               sizeof(uint64_t));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Looking up existing data under label %s\n", label);
-// Test for the content of the existing ID
-
-  ash->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
-                                                &ash->identity,
-                                                label,
-                                                &ref_error,
-                                                ash,
-                                                &ref_add_cb,
-                                                ash);
-  GNUNET_free (label);
-}
-
-/**
-     * Check an attestation reference store message
-     *
-     * @param cls unused
-     * @param sam the message to check
-     */
-static int
-check_reference_store_message (void *cls,
-                               const struct
-                               AttributeStoreMessage *sam)
-{
-  uint16_t size;
-
-  size = ntohs (sam->header.size);
-  if (size <= sizeof(struct AttributeStoreMessage))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  return GNUNET_OK;
-}
-
-
-/**
-    * Handle an attestation reference store message
-    *
-    * @param cls our client
-    * @param sam the message to handle
-    */
-static void
-handle_reference_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 REFERENCE_STORE message\n");
-
-  data_len = ntohs (sam->attr_len);
-  ash = GNUNET_new (struct AttributeStoreHandle);
-  ash->reference = GNUNET_RECLAIM_ATTESTATION_REF_deserialize ((char *) &sam[1],
-                                                               data_len);
-  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);
-
-
-  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 (&reference_store_task, ash);
-}
-/**
  * Send a deletion success response
  *
  * @param adh our attribute deletion handle
@@ -1567,19 +1298,18 @@ ticket_iter (void *cls,
   int has_changed = GNUNET_NO;
   for (int i = 0; i < rd_count; i++)
   {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF != rd[i].record_type)
+    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF != rd[i].record_type)
       continue;
     if (adh->claim != NULL)
-      if (0 != memcmp (rd[i].data, &adh->claim->id, sizeof(uint64_t)))
+      if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data,
+                                                    &adh->claim->id))
         continue;
     if (adh->attest != NULL)
-      if (0 != memcmp (rd[i].data, &adh->attest->id, sizeof(uint64_t)))
-        continue;
-    if (adh->reference != NULL)
-      if (0 != memcmp (rd[i].data, &adh->reference->id, sizeof(uint64_t)))
+      if (GNUNET_YES != GNUNET_RECLAIM_id_is_equal (rd[i].data,
+                                                    &adh->attest->id))
         continue;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Attribute or Attestation/Reference to delete found (%s)\n",
+                "Attribute or Attestation to delete found (%s)\n",
                 adh->label);
     has_changed = GNUNET_YES;
     break;
@@ -1670,16 +1400,14 @@ update_tickets (void *cls)
   for (int i = 0; i < le->rd_count; i++)
   {
     if (adh->claim != NULL)
-      if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF == rd[i].record_type)
-          && (0 == memcmp (rd[i].data, &adh->claim->id, sizeof(uint64_t))))
+      if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type)
+          && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data,
+                                                        &adh->claim->id)))
         continue;
     if (adh->attest != NULL)
-      if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF == rd[i].record_type)
-          && (0 == memcmp (rd[i].data, &adh->attest->id, sizeof(uint64_t))))
-        continue;
-    if (adh->reference != NULL)
-      if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF == rd[i].record_type)
-          && (0 == memcmp (rd[i].data, &adh->reference->id, sizeof(uint64_t))))
+      if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF == rd[i].record_type)
+          && (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data,
+                                                        &adh->attest->id)))
         continue;
     rd_new[j] = rd[i];
     j++;
@@ -1820,15 +1548,15 @@ handle_attribute_delete_message (void *cls,
   data_len = ntohs (dam->attr_len);
 
   adh = GNUNET_new (struct AttributeDeleteHandle);
-  adh->claim = GNUNET_RECLAIM_ATTRIBUTE_deserialize ((char *) &dam[1],
+  adh->claim = GNUNET_RECLAIM_attribute_deserialize ((char *) &dam[1],
                                                      data_len);
-  adh->reference = NULL;
   adh->attest = NULL;
 
   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_STRINGS_data_to_string_alloc (&adh->claim->id,
+                                           sizeof(adh->claim->id));
   GNUNET_SERVICE_client_continue (idp->client);
   adh->client = idp;
   GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
@@ -1841,6 +1569,7 @@ handle_attribute_delete_message (void *cls,
                                                adh);
 }
 
+
 /**
    * Attestation deleted callback
    *
@@ -1867,6 +1596,7 @@ attest_delete_cont (void *cls, int32_t success, const char *emsg)
   GNUNET_SCHEDULER_add_now (&start_ticket_update, adh);
 }
 
+
 /**
  * Check attestation delete message format
  *
@@ -1908,15 +1638,15 @@ handle_attestation_delete_message (void *cls,
   data_len = ntohs (dam->attr_len);
 
   adh = GNUNET_new (struct AttributeDeleteHandle);
-  adh->attest = GNUNET_RECLAIM_ATTESTATION_deserialize ((char *) &dam[1],
+  adh->attest = GNUNET_RECLAIM_attestation_deserialize ((char *) &dam[1],
                                                         data_len);
-  adh->reference = NULL;
   adh->claim = NULL;
 
   adh->r_id = ntohl (dam->id);
   adh->identity = dam->identity;
   adh->label
-    = GNUNET_STRINGS_data_to_string_alloc (&adh->attest->id, sizeof(uint64_t));
+    = GNUNET_STRINGS_data_to_string_alloc (&adh->attest->id,
+                                           sizeof(adh->attest->id));
   GNUNET_SERVICE_client_continue (idp->client);
   adh->client = idp;
   GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
@@ -1930,214 +1660,236 @@ handle_attestation_delete_message (void *cls,
 }
 
 
+/*************************************************
+* Attrubute iteration
+*************************************************/
+
 
 /**
-* Reference deleted callback
-*
-* @param cls our handle
-* @param success success status
-* @param emsg error message (NULL if success=GNUNET_OK)
-*/
+ * Done iterating over attributes
+ *
+ * @param cls our iterator handle
+ */
 static void
-reference_delete_cont (void *cls, int32_t success, const char *emsg)
+attr_iter_finished (void *cls)
 {
-  struct AttributeDeleteHandle *adh = cls;
+  struct Iterator *ai = cls;
+  struct GNUNET_MQ_Envelope *env;
+  struct AttributeResultMessage *arm;
 
-  adh->ns_qe = NULL;
-  if (GNUNET_SYSERR == success)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Error deleting reference %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);
-  send_delete_response (adh, GNUNET_OK);
-  cleanup_adh (adh);
-  return;
+  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);
 }
 
+
+/**
+ * Error iterating over attributes. Abort.
+ *
+ * @param cls our attribute iteration handle
+ */
 static void
-ref_del_cb (void *cls,
-            const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
-            const char *label,
-            unsigned int rd_count,
-            const struct GNUNET_GNSRECORD_Data *rd)
+attr_iter_error (void *cls)
 {
+  struct Iterator *ai = cls;
 
-  struct AttributeDeleteHandle *adh = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
+  attr_iter_finished (ai);
+}
+
+
+/**
+ * Got record. Return if it is an attribute or attestation.
+ *
+ * @param cls our attribute iterator
+ * @param zone zone we are iterating
+ * @param label label of the records
+ * @param rd_count record count
+ * @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)
+{
+  struct Iterator *ai = cls;
+  struct GNUNET_MQ_Envelope *env;
   char *data_tmp;
-  struct GNUNET_GNSRECORD_Data rd_new[rd_count - 1];
-  struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *ref;
-  size_t attr_len;
 
-  if (0 == rd_count )
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to find Attestation entry for Attestation reference\n");
-    cleanup_adh (adh);
-    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
-    return;
-  }
-  if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR != rd[0].record_type)
+  if ((rd_count != 1) ||
+      (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd->record_type))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Intended Reference location is not an attestation\n");
-    cleanup_adh (adh);
-    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
     return;
   }
-  rd_new[0] = rd[0];
-  int i;
-  int j = 1;
-  for (i = 1; i<rd_count; i++)
-  {
-    data_tmp = GNUNET_malloc (rd[i].data_size);
-    GNUNET_memcpy (data_tmp, rd[i].data, rd[i].data_size);
-    attr_len = htons (rd[i].data_size);
-    ref = GNUNET_RECLAIM_ATTESTATION_REF_deserialize (data_tmp, attr_len);
-    if (NULL == ref )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Unable to parse attestation reference from %s\n",
-                  data_tmp);
-      rd_new[j] = rd[i];
-      j += 1;
-      continue;
-    }
-    if ((strcmp (adh->reference->name,ref->name) == 0)&&
-        (strcmp (adh->reference->reference_value,ref->reference_value)==0) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Found reference to delete.\n");
-    }
-    else
-    {
-      rd_new[j] = rd[i];
-      j += 1;
-    }
-    GNUNET_free (data_tmp);
-  }
-  adh->ns_qe = GNUNET_NAMESTORE_records_store (nsh,
-                                               &adh->identity,
-                                               label,
-                                               j,
-                                               rd_new,
-                                               &reference_delete_cont,
-                                               adh);
+  struct AttributeResultMessage *arm;
+  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);
 }
 
+
 /**
- * Check an attestation reference delete message
+ * Iterate over zone to get attributes
  *
- * @param cls unused
- * @param sam the message to check
+ * @param cls our client
+ * @param ais_msg the iteration message to start
  */
-static int
-check_reference_delete_message (void *cls,
-                                const struct AttributeDeleteMessage *dam)
+static void
+handle_iteration_start (void *cls,
+                        const struct AttributeIterationStartMessage *ais_msg)
 {
-  uint16_t size;
+  struct IdpClient *idp = cls;
+  struct Iterator *ai;
 
-  size = ntohs (dam->header.size);
-  if (size <= sizeof(struct AttributeDeleteMessage))
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ATTRIBUTE_ITERATION_START message\n");
+  ai = GNUNET_new (struct Iterator);
+  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);
+}
+
+
+/**
+ * Handle iteration stop message from client
+ *
+ * @param cls the client
+ * @param ais_msg the stop message
+ */
+static void
+handle_iteration_stop (void *cls,
+                       const struct AttributeIterationStopMessage *ais_msg)
+{
+  struct IdpClient *idp = cls;
+  struct Iterator *ai;
+  uint32_t rid;
+
+  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);
-    return GNUNET_SYSERR;
+    GNUNET_SERVICE_client_drop (idp->client);
+    return;
   }
-  return GNUNET_OK;
+  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
+  GNUNET_free (ai);
+  GNUNET_SERVICE_client_continue (idp->client);
 }
 
+
 /**
- * Handle reference deletion
+ * Client requests next attribute from iterator
  *
- * @param cls our client
- * @param dam deletion message
+ * @param cls the client
+ * @param ais_msg the message
  */
 static void
-handle_reference_delete_message (void *cls,
-                                 const struct AttributeDeleteMessage *dam)
+handle_iteration_next (void *cls,
+                       const struct AttributeIterationNextMessage *ais_msg)
 {
-  struct AttributeDeleteHandle *adh;
   struct IdpClient *idp = cls;
-  size_t data_len;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REFERENCE_DELETE message\n");
-  data_len = ntohs (dam->attr_len);
-  adh = GNUNET_new (struct AttributeDeleteHandle);
-  adh->reference = GNUNET_RECLAIM_ATTESTATION_REF_deserialize ((char *) &dam[1],
-                                                               data_len);
-  adh->attest = NULL;
-  adh->claim = NULL;
+  struct Iterator *ai;
+  uint32_t rid;
 
-  adh->r_id = ntohl (dam->id);
-  adh->identity = dam->identity;
-  adh->label
-    = GNUNET_STRINGS_data_to_string_alloc (&adh->reference->id,
-                                           sizeof(uint64_t));
+  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);
-  adh->client = idp;
-  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
-  adh->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
-                                                &adh->identity,
-                                                adh->label,
-                                                &ref_del_error,
-                                                adh,
-                                                &ref_del_cb,
-                                                adh);
 }
 
 
-
 /*************************************************
-* Attrubute iteration
+* Attestation iteration
 *************************************************/
 
 
 /**
- * Done iterating over attributes
+ * Done iterating over attestations
  *
  * @param cls our iterator handle
  */
 static void
-attr_iter_finished (void *cls)
+attest_iter_finished (void *cls)
 {
-  struct AttributeIterator *ai = cls;
+  struct Iterator *ai = cls;
   struct GNUNET_MQ_Envelope *env;
-  struct AttributeResultMessage *arm;
+  struct AttestationResultMessage *arm;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
-  env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTESTATION_RESULT message\n");
+  env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_RESULT);
   arm->id = htonl (ai->request_id);
-  arm->attr_len = htons (0);
+  arm->attestation_len = htons (0);
   GNUNET_MQ_send (ai->client->mq, env);
-  GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head,
-                               ai->client->attr_iter_tail,
+  GNUNET_CONTAINER_DLL_remove (ai->client->attest_iter_head,
+                               ai->client->attest_iter_tail,
                                ai);
   GNUNET_free (ai);
 }
 
 
 /**
- * Error iterating over attributes. Abort.
+ * Error iterating over attestations. Abort.
  *
  * @param cls our attribute iteration handle
  */
 static void
-attr_iter_error (void *cls)
+attest_iter_error (void *cls)
 {
-  struct AttributeIterator *ai = cls;
+  struct Iterator *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 attestations\n");
+  attest_iter_finished (ai);
 }
 
 
 /**
- * Got record. Return if it is an attribute or attestation/reference.
+ * Got record. Return attestation.
  *
  * @param cls our attribute iterator
  * @param zone zone we are iterating
@@ -2146,110 +1898,40 @@ 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)
+attest_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 Iterator *ai = cls;
   struct GNUNET_MQ_Envelope *env;
+  struct AttestationResultMessage *arm;
   char *data_tmp;
 
-  if (rd_count == 0)
+  if ((rd_count != 1) ||
+      (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTESTATION != rd->record_type))
   {
     GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
     return;
   }
-  if (rd_count > 1)
-  {
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR_REF == rd[0].record_type)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Found Ticket. Ignoring.\n");
-      GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
-      return;
-    }
-    else if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR != rd[0].record_type)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Non-Attestation record with multiple entries found: %u\n",
-                  rd[0].record_type);
-      GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
-      return;
-    }
-  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attestation under: %s\n",
+              label);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending ATTESTATION_RESULT message\n");
+  env = GNUNET_MQ_msg_extra (arm,
+                             rd->data_size,
+                             GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_RESULT);
+  arm->id = htonl (ai->request_id);
+  arm->attestation_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);
 
-  for (int i = 0; i<rd_count; i++)
-  {
-    if ((GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR != rd[i].record_type) &&
-        (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR != rd[i].record_type) &&
-        (GNUNET_GNSRECORD_TYPE_RECLAIM_REFERENCE != rd[i].record_type))
-    {
-      GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
-      return;
-    }
-
-    if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTR == rd[i].record_type )
-    {
-      struct AttributeResultMessage *arm;
-      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[i].data_size,
-                                 GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
-      arm->id = htonl (ai->request_id);
-      arm->attr_len = htons (rd[i].data_size);
-      GNUNET_CRYPTO_ecdsa_key_get_public (zone, &arm->identity);
-      data_tmp = (char *) &arm[1];
-      GNUNET_memcpy (data_tmp, rd[i].data, rd[i].data_size);
-      GNUNET_MQ_send (ai->client->mq, env);
-    }
-    else
-    {
-      if (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTEST_ATTR == rd[i].record_type )
-      {
-        struct AttributeResultMessage *arm;
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attestation under: %s\n",
-                    label);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Sending ATTESTATION_RESULT message\n");
-        env = GNUNET_MQ_msg_extra (arm,
-                                   rd[i].data_size,
-                                   GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_RESULT);
-        arm->id = htonl (ai->request_id);
-        arm->attr_len = htons (rd[i].data_size);
-        GNUNET_CRYPTO_ecdsa_key_get_public (zone, &arm->identity);
-        data_tmp = (char *) &arm[1];
-        GNUNET_memcpy (data_tmp, rd[i].data, rd[i].data_size);
-        GNUNET_MQ_send (ai->client->mq, env);
-      }
-      else
-      {
-        struct ReferenceResultMessage *rrm;
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found reference under: %s\n",
-                    label);
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Sending REFERENCE_RESULT message\n");
-        env = GNUNET_MQ_msg_extra (rrm,
-                                   rd[i].data_size + rd[0].data_size,
-                                   GNUNET_MESSAGE_TYPE_RECLAIM_REFERENCE_RESULT);
-        rrm->id = htonl (ai->request_id);
-        rrm->attest_len = htons (rd[0].data_size);
-        rrm->ref_len = htons (rd[i].data_size);
-        GNUNET_CRYPTO_ecdsa_key_get_public (zone, &rrm->identity);
-        data_tmp = (char *) &rrm[1];
-        GNUNET_memcpy (data_tmp, rd[0].data, rd[0].data_size);
-        data_tmp += rd[0].data_size;
-        GNUNET_memcpy (data_tmp, rd[i].data, rd[i].data_size);
-        GNUNET_MQ_send (ai->client->mq, env);
-      }
-    }
-  }
+  GNUNET_MQ_send (ai->client->mq, env);
 }
 
+
 /**
  * Iterate over zone to get attributes
  *
@@ -2257,27 +1939,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_attestation_iteration_start (void *cls,
+                                    const struct
+                                    AttestationIterationStartMessage *ais_msg)
 {
   struct IdpClient *idp = cls;
-  struct AttributeIterator *ai;
+  struct Iterator *ai;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received ATTRIBUTE_ITERATION_START message\n");
-  ai = GNUNET_new (struct AttributeIterator);
+              "Received ATTESTATION_ITERATION_START message\n");
+  ai = GNUNET_new (struct Iterator);
   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);
+  GNUNET_CONTAINER_DLL_insert (idp->attest_iter_head, idp->attest_iter_tail,
+                               ai);
   ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                                      &ai->identity,
-                                                     &attr_iter_error,
+                                                     &attest_iter_error,
                                                      ai,
-                                                     &attr_iter_cb,
+                                                     &attest_iter_cb,
                                                      ai,
-                                                     &attr_iter_finished,
+                                                     &attest_iter_finished,
                                                      ai);
   GNUNET_SERVICE_client_continue (idp->client);
 }
@@ -2290,18 +1974,19 @@ handle_iteration_start (void *cls,
  * @param ais_msg the stop message
  */
 static void
-handle_iteration_stop (void *cls,
-                       const struct AttributeIterationStopMessage *ais_msg)
+handle_attestation_iteration_stop (void *cls,
+                                   const struct
+                                   AttestationIterationStopMessage *ais_msg)
 {
   struct IdpClient *idp = cls;
-  struct AttributeIterator *ai;
+  struct Iterator *ai;
   uint32_t rid;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Received `%s' message\n",
-              "ATTRIBUTE_ITERATION_STOP");
+              "ATTESTATION_ITERATION_STOP");
   rid = ntohl (ais_msg->id);
-  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
+  for (ai = idp->attest_iter_head; NULL != ai; ai = ai->next)
     if (ai->request_id == rid)
       break;
   if (NULL == ai)
@@ -2310,30 +1995,32 @@ handle_iteration_stop (void *cls,
     GNUNET_SERVICE_client_drop (idp->client);
     return;
   }
-  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
+  GNUNET_CONTAINER_DLL_remove (idp->attest_iter_head, idp->attest_iter_tail,
+                               ai);
   GNUNET_free (ai);
   GNUNET_SERVICE_client_continue (idp->client);
 }
 
 
 /**
- * Client requests next attribute from iterator
+ * Client requests next attestation from iterator
  *
  * @param cls the client
  * @param ais_msg the message
  */
 static void
-handle_iteration_next (void *cls,
-                       const struct AttributeIterationNextMessage *ais_msg)
+handle_attestation_iteration_next (void *cls,
+                                   const struct
+                                   AttestationIterationNextMessage *ais_msg)
 {
   struct IdpClient *idp = cls;
-  struct AttributeIterator *ai;
+  struct Iterator *ai;
   uint32_t rid;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received ATTRIBUTE_ITERATION_NEXT message\n");
+              "Received ATTESTATION_ITERATION_NEXT message\n");
   rid = ntohl (ais_msg->id);
-  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
+  for (ai = idp->attest_iter_head; NULL != ai; ai = ai->next)
     if (ai->request_id == rid)
       break;
   if (NULL == ai)
@@ -2587,19 +2274,10 @@ GNUNET_SERVICE_MAIN (
                          GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_DELETE,
                          struct AttributeDeleteMessage,
                          NULL),
-  GNUNET_MQ_hd_var_size (reference_store_message,
-                         GNUNET_MESSAGE_TYPE_RECLAIM_REFERENCE_STORE,
-                         struct AttributeStoreMessage,
-                         NULL),
-  GNUNET_MQ_hd_var_size (reference_delete_message,
-                         GNUNET_MESSAGE_TYPE_RECLAIM_REFERENCE_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_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,
@@ -2608,6 +2286,19 @@ GNUNET_SERVICE_MAIN (
                            GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP,
                            struct AttributeIterationStopMessage,
                            NULL),
+  GNUNET_MQ_hd_fixed_size (attestation_iteration_start,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_START,
+                           struct AttestationIterationStartMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (attestation_iteration_next,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_NEXT,
+                           struct AttestationIterationNextMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (attestation_iteration_stop,
+                           GNUNET_MESSAGE_TYPE_RECLAIM_ATTESTATION_ITERATION_STOP,
+                           struct AttestationIterationStopMessage,
+                           NULL),
+
   GNUNET_MQ_hd_var_size (issue_ticket_message,
                          GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET,
                          struct IssueTicketMessage,