Refactoring reclaim attestations

1 files changed, 91 insertions, 433 deletions

diff --git a/src/reclaim/plugin_rest_reclaim.c b/src/reclaim/plugin_rest_reclaim.c
index 9a6af6bcf..fcb34e11a 100644
--- a/src/reclaim/plugin_rest_reclaim.c
+++ b/src/reclaim/plugin_rest_reclaim.c
@@ -48,9 +48,9 @@
 #define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES "/reclaim/attributes"
 
 /**
-   * Attestation namespace
-   */
-#define GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE "/reclaim/attestation"
+ * Attestation namespace
+ */
+#define GNUNET_REST_API_NS_RECLAIM_ATTESTATION "/reclaim/attestation"
 
 /**
  * Ticket namespace
@@ -167,7 +167,7 @@ struct RequestHandle
   /**
    * Attribute claim list
    */
-  struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList *attr_list;
+  struct GNUNET_RECLAIM_AttributeList *attr_list;
 
   /**
    * IDENTITY Operation
@@ -190,6 +190,12 @@ struct RequestHandle
   struct GNUNET_RECLAIM_AttributeIterator *attr_it;
 
   /**
+   * Attribute iterator
+   */
+  struct GNUNET_RECLAIM_AttestationIterator *attest_it;
+
+
+  /**
    * Ticket iterator
    */
   struct GNUNET_RECLAIM_TicketIterator *ticket_it;
@@ -247,8 +253,6 @@ struct RequestHandle
 static void
 cleanup_handle (struct RequestHandle *handle)
 {
-  struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_entry;
-  struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_tmp;
   struct EgoEntry *ego_entry;
   struct EgoEntry *ego_tmp;
 
@@ -261,6 +265,8 @@ cleanup_handle (struct RequestHandle *handle)
     GNUNET_IDENTITY_disconnect (handle->identity_handle);
   if (NULL != handle->attr_it)
     GNUNET_RECLAIM_get_attributes_stop (handle->attr_it);
+  if (NULL != handle->attest_it)
+    GNUNET_RECLAIM_get_attestations_stop (handle->attest_it);
   if (NULL != handle->ticket_it)
     GNUNET_RECLAIM_ticket_iteration_stop (handle->ticket_it);
   if (NULL != handle->idp)
@@ -269,19 +275,7 @@ cleanup_handle (struct RequestHandle *handle)
     GNUNET_free (handle->url);
   if (NULL != handle->emsg)
     GNUNET_free (handle->emsg);
-  if (NULL != handle->attr_list)
-  {
-    for (claim_entry = handle->attr_list->list_head; NULL != claim_entry;)
-    {
-      claim_tmp = claim_entry;
-      claim_entry = claim_entry->next;
-      GNUNET_free (claim_tmp->claim);
-      GNUNET_free (claim_tmp->attest);
-      GNUNET_free (claim_tmp->reference);
-      GNUNET_free (claim_tmp);
-    }
-    GNUNET_free (handle->attr_list);
-  }
+  GNUNET_RECLAIM_attribute_list_destroy (handle->attr_list);
   for (ego_entry = handle->ego_head; NULL != ego_entry;)
   {
     ego_tmp = ego_entry;
@@ -366,6 +360,7 @@ finished_cont (void *cls, int32_t success, const char *emsg)
   GNUNET_SCHEDULER_add_now (&cleanup_handle_delayed, handle);
 }
 
+
 static void
 delete_finished_cb (void *cls, int32_t success, const char *emsg)
 {
@@ -382,6 +377,7 @@ delete_finished_cb (void *cls, int32_t success, const char *emsg)
   GNUNET_SCHEDULER_add_now (&cleanup_handle_delayed, handle);
 }
 
+
 /**
  * Return attributes for identity
  *
@@ -456,85 +452,6 @@ ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 
 
 static void
-add_attestation_ref_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                          const char *url,
-                          void *cls)
-{
-  struct RequestHandle *handle = cls;
-  const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
-  const char *identity;
-  struct EgoEntry *ego_entry;
-  struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *attribute;
-  struct GNUNET_TIME_Relative exp;
-  char term_data[handle->rest_handle->data_size + 1];
-  json_t *data_json;
-  json_error_t err;
-  struct GNUNET_JSON_Specification attrspec[] =
-  { GNUNET_RECLAIM_JSON_spec_claim_attest_ref (&attribute),
-    GNUNET_JSON_spec_end () };
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Adding an attestation reference for %s.\n",
-              handle->url);
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + strlen (
-        "reference/") + 1 >= strlen (
-        handle->url))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  identity = handle->url + strlen (
-    GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + strlen ("reference/")
-             + 1;
-  for (ego_entry = handle->ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next)
-    if (0 == strcmp (identity, ego_entry->identifier))
-      break;
-  if (NULL == ego_entry)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown (%s)\n", identity);
-    return;
-  }
-  identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-  if (0 >= handle->rest_handle->data_size)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-
-  term_data[handle->rest_handle->data_size] = '\0';
-  GNUNET_memcpy (term_data,
-                 handle->rest_handle->data,
-                 handle->rest_handle->data_size);
-  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_JSON_parse (data_json, attrspec, NULL, NULL));
-  json_decref (data_json);
-  if (NULL == attribute)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse attestation reference from %s\n",
-                term_data);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  /**
-   * New ID for attribute
-   */
-  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&attribute->id))
-    attribute->id = attribute->id_attest;
-  handle->idp = GNUNET_RECLAIM_connect (cfg);
-  exp = GNUNET_TIME_UNIT_HOURS;
-  handle->idp_op = GNUNET_RECLAIM_attestation_reference_store (handle->idp,
-                                                               identity_priv,
-                                                               attribute,
-                                                               &exp,
-                                                               &finished_cont,
-                                                               handle);
-  GNUNET_JSON_parse_free (attrspec);
-}
-
-static void
 parse_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
                         const char *url,
                         void *cls)
@@ -576,16 +493,16 @@ parse_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
   if (0 == strcmp (type_str, "JWT"))
   {
-  // The value is a JWT
-  char *decoded_jwt;
-  char delim[] = ".";
-  char *jwt_body = strtok (val_str, delim);
-  jwt_body = strtok (NULL, delim);
-  GNUNET_STRINGS_base64_decode (jwt_body, strlen (jwt_body),
-                                (void **) &decoded_jwt);
-  resp = GNUNET_REST_create_response (decoded_jwt);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free (decoded_jwt);
+    // The value is a JWT
+    char *decoded_jwt;
+    char delim[] = ".";
+    char *jwt_body = strtok (val_str, delim);
+    jwt_body = strtok (NULL, delim);
+    GNUNET_STRINGS_base64_decode (jwt_body, strlen (jwt_body),
+                                  (void **) &decoded_jwt);
+    resp = GNUNET_REST_create_response (decoded_jwt);
+    handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
+    GNUNET_free (decoded_jwt);
   }
   else
   {
@@ -598,42 +515,31 @@ parse_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   json_decref (data_json);
 }
 
+
 static void
 add_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
                       const char *url,
                       void *cls)
 {
   struct RequestHandle *handle = cls;
-  /* Check for substring "reference" */
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) < strlen (
+  /* Check for substring "parse"
+   * FIXME UGLY! */
+  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION) < strlen (
         handle->url))
   {
-    if ( strncmp ("reference/", (handle->url + strlen (
-                                   GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE)
-                                 + 1), strlen (
-                    "reference/")) == 0)
+    if (strncmp ("parse", (handle->url + strlen (
+                             GNUNET_REST_API_NS_RECLAIM_ATTESTATION)
+                           + 1), strlen (
+                   "parse")) == 0)
     {
-      add_attestation_ref_cont (con_handle,url,cls);
+      parse_attestation_cont (con_handle,url,cls);
       return;
     }
   }
-  /* Check for substring "parse" */
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) < strlen (
-      handle->url))
-      {
-        if ( strncmp ("parse", (handle->url + strlen (
-                          GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE)
-                        + 1), strlen (
-            "parse")) == 0)
-        {
-          parse_attestation_cont (con_handle,url,cls);
-          return;
-        }
-      }
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   const char *identity;
   struct EgoEntry *ego_entry;
-  struct GNUNET_RECLAIM_ATTESTATION_Claim *attribute;
+  struct GNUNET_RECLAIM_Attestation *attribute;
   struct GNUNET_TIME_Relative exp;
   char term_data[handle->rest_handle->data_size + 1];
   json_t *data_json;
@@ -645,7 +551,7 @@ add_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Adding an attestation for %s.\n",
               handle->url);
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) >= strlen (
+  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION) >= strlen (
         handle->url))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
@@ -653,7 +559,7 @@ add_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
     return;
   }
   identity = handle->url + strlen (
-    GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + 1;
+    GNUNET_REST_API_NS_RECLAIM_ATTESTATION) + 1;
 
   for (ego_entry = handle->ego_head; NULL != ego_entry;
        ego_entry = ego_entry->next)
@@ -705,104 +611,6 @@ add_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   GNUNET_JSON_parse_free (attrspec);
 }
 
-/**
- * Collect all references for an ego
- *
- */
-static void
-ref_collect (void *cls,
-             const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-             const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr,
-             const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
-             const struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *reference)
-{
-  struct RequestHandle *handle = cls;
-  json_t *attr_obj;
-  char *id_str;
-  char *id_attest_str;
-
-  if (NULL == reference)
-  {
-    GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
-    return;
-  }
-
-  if ((NULL == reference->name) || (NULL == reference->reference_value))
-  {
-    return;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding reference: %s\n",
-              reference->name);
-  attr_obj = json_object ();
-  json_object_set_new (attr_obj, "name", json_string (reference->name));
-  json_object_set_new (attr_obj, "ref_value", json_string (
-                         reference->reference_value));
-  id_str = GNUNET_STRINGS_data_to_string_alloc (&reference->id,
-                                                sizeof(reference->id));
-  id_attest_str = GNUNET_STRINGS_data_to_string_alloc (&reference->id_attest,
-                                                       sizeof(reference->id_attest));
-  json_object_set_new (attr_obj, "id", json_string (id_str));
-  json_object_set_new (attr_obj, "ref_id", json_string (id_attest_str));
-  json_array_append (handle->resp_object, attr_obj);
-  json_decref (attr_obj);
-}
-
-/**
- * Lists references for identity request
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-static void
-list_reference_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                     const char *url,
-                     void *cls)
-{
-  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
-  struct RequestHandle *handle = cls;
-  struct EgoEntry *ego_entry;
-  char *identity;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Getting references for %s.\n",
-              handle->url);
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + strlen (
-        "reference/") + 1 >= strlen (
-        handle->url))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  identity = handle->url + strlen (
-    GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + strlen ("reference/")
-             + 1;
-  for (ego_entry = handle->ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next)
-    if (0 == strcmp (identity, ego_entry->identifier))
-      break;
-  handle->resp_object = json_array ();
-
-  if (NULL == ego_entry)
-  {
-    // Done
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
-    GNUNET_SCHEDULER_add_now (&return_response, handle);
-    return;
-  }
-  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-  handle->idp = GNUNET_RECLAIM_connect (cfg);
-  handle->attr_it = GNUNET_RECLAIM_get_attributes_start (handle->idp,
-                                                         priv_key,
-                                                         &collect_error_cb,
-                                                         handle,
-                                                         &ref_collect,
-                                                         handle,
-                                                         &collect_finished_cb,
-                                                         handle);
-}
 
 /**
  * Collect all attestations for an ego
@@ -811,9 +619,7 @@ list_reference_cont (struct GNUNET_REST_RequestHandle *con_handle,
 static void
 attest_collect (void *cls,
                 const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-                const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr,
-                const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
-                const struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *reference)
+                const struct GNUNET_RECLAIM_Attestation *attest)
 {
   struct RequestHandle *handle = cls;
   json_t *attr_obj;
@@ -822,12 +628,6 @@ attest_collect (void *cls,
   char *id_str;
 
 
-  if (NULL != reference)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Attestation Collection with Reference\n");
-    return;
-  }
   if (NULL == attest)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -847,15 +647,16 @@ attest_collect (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attestation: %s\n",
               attest->name);
 
-  tmp_value = GNUNET_RECLAIM_ATTESTATION_value_to_string (attest->type,
+  tmp_value = GNUNET_RECLAIM_attestation_value_to_string (attest->type,
                                                           attest->data,
                                                           attest->data_size);
   attr_obj = json_object ();
   json_object_set_new (attr_obj, "value", json_string (tmp_value));
   json_object_set_new (attr_obj, "name", json_string (attest->name));
-  type = GNUNET_RECLAIM_ATTESTATION_number_to_typename (attest->type);
+  type = GNUNET_RECLAIM_attestation_number_to_typename (attest->type);
   json_object_set_new (attr_obj, "type", json_string (type));
-  id_str = GNUNET_STRINGS_data_to_string_alloc (&attest->id, sizeof(attest->id));
+  id_str = GNUNET_STRINGS_data_to_string_alloc (&attest->id,
+                                                sizeof(attest->id));
   json_object_set_new (attr_obj, "id", json_string (id_str));
   json_array_append (handle->resp_object, attr_obj);
   json_decref (attr_obj);
@@ -877,19 +678,6 @@ list_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
                        void *cls)
 {
   struct RequestHandle *handle = cls;
-  /* Check for substring "reference" */
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) < strlen (
-        handle->url))
-  {
-    if ( strncmp ("reference/", (handle->url + strlen (
-                                   GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE)
-                                 + 1), strlen (
-                    "reference/")) == 0)
-    {
-      list_reference_cont (con_handle,url,cls);
-      return;
-    }
-  }
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
   struct EgoEntry *ego_entry;
   char *identity;
@@ -897,7 +685,7 @@ list_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Getting attestations for %s.\n",
               handle->url);
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) >= strlen (
+  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION) >= strlen (
         handle->url))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
@@ -905,7 +693,7 @@ list_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
     return;
   }
   identity = handle->url + strlen (
-    GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + 1;
+    GNUNET_REST_API_NS_RECLAIM_ATTESTATION) + 1;
 
   for (ego_entry = handle->ego_head; NULL != ego_entry;
        ego_entry = ego_entry->next)
@@ -923,109 +711,14 @@ list_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
   priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   handle->idp = GNUNET_RECLAIM_connect (cfg);
-  handle->attr_it = GNUNET_RECLAIM_get_attributes_start (handle->idp,
-                                                         priv_key,
-                                                         &collect_error_cb,
-                                                         handle,
-                                                         &attest_collect,
-                                                         handle,
-                                                         &collect_finished_cb,
-                                                         handle);
-}
-
-/**
- * Deletes reference from an identity
- *
- * @param con_handle the connection handle
- * @param url the url
- * @param cls the RequestHandle
- */
-static void
-delete_attestation_ref_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                             const char *url,
-                             void *cls)
-{
-  struct RequestHandle *handle = cls;
-  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
-  struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *attr;
-  struct EgoEntry *ego_entry;
-  char *identity;
-  char *identity_id_str;
-  char *id;
-  char term_data[handle->rest_handle->data_size + 1];
-  json_t *data_json;
-  json_error_t err;
-
-  struct GNUNET_JSON_Specification attrspec[] =
-  { GNUNET_RECLAIM_JSON_spec_claim_attest_ref (&attr),
-    GNUNET_JSON_spec_end () };
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Deleting attestation reference.\n");
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + strlen (
-        "reference/") + 1 >= strlen (
-        handle->url))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  identity_id_str = strdup (handle->url + strlen (
-                              GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE)
-                            + strlen ("reference/")
-                            + 1);
-  identity = strtok (identity_id_str, "/");
-  id = strtok (NULL, "/");
-
-  if ((NULL == identity) || (NULL == id))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  for (ego_entry = handle->ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next)
-    if (0 == strcmp (identity, ego_entry->identifier))
-      break;
-  handle->resp_object = json_array ();
-  if (NULL == ego_entry)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
-    GNUNET_SCHEDULER_add_now (&return_response, handle);
-    return;
-  }
-  priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
-  if (0 >= handle->rest_handle->data_size)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-
-  term_data[handle->rest_handle->data_size] = '\0';
-  GNUNET_memcpy (term_data,
-                 handle->rest_handle->data,
-                 handle->rest_handle->data_size);
-  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_JSON_parse (data_json, attrspec, NULL, NULL));
-  json_decref (data_json);
-  if (NULL == attr)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse attestation reference from %s\n",
-                term_data);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  GNUNET_STRINGS_string_to_data (id, strlen (id), &attr->id, sizeof(attr->id));
-
-  handle->idp = GNUNET_RECLAIM_connect (cfg);
-  handle->idp_op = GNUNET_RECLAIM_attestation_reference_delete (handle->idp,
-                                                                priv_key,
-                                                                attr,
-                                                                &
-                                                                delete_finished_cb,
-                                                                handle);
-  GNUNET_JSON_parse_free (attrspec);
+  handle->attest_it = GNUNET_RECLAIM_get_attestations_start (handle->idp,
+                                                           priv_key,
+                                                           &collect_error_cb,
+                                                           handle,
+                                                           &attest_collect,
+                                                           handle,
+                                                           &collect_finished_cb,
+                                                           handle);
 }
 
 
@@ -1042,28 +735,15 @@ delete_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
                          void *cls)
 {
   struct RequestHandle *handle = cls;
-  /* Check for substring "reference" */
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) < strlen (
-        handle->url))
-  {
-    if ( strncmp ("reference", (handle->url + strlen (
-                                  GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE)
-                                + 1), strlen (
-                    "reference")) == 0)
-    {
-      delete_attestation_ref_cont (con_handle,url,cls);
-      return;
-    }
-  }
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
-  struct GNUNET_RECLAIM_ATTESTATION_Claim attr;
+  struct GNUNET_RECLAIM_Attestation attr;
   struct EgoEntry *ego_entry;
   char *identity_id_str;
   char *identity;
   char *id;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting attestation.\n");
-  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) >= strlen (
+  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTESTATION) >= strlen (
         handle->url))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
@@ -1072,7 +752,7 @@ delete_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
   identity_id_str =
     strdup (handle->url + strlen (
-              GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE) + 1);
+              GNUNET_REST_API_NS_RECLAIM_ATTESTATION) + 1);
   identity = strtok (identity_id_str, "/");
   id = strtok (NULL, "/");
   if ((NULL == identity) || (NULL == id))
@@ -1098,7 +778,7 @@ delete_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
   priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   handle->idp = GNUNET_RECLAIM_connect (cfg);
-  memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_ATTESTATION_Claim));
+  memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_Attestation));
   GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof(attr.id));
   attr.name = "";
   handle->idp_op = GNUNET_RECLAIM_attestation_delete (handle->idp,
@@ -1109,6 +789,7 @@ delete_attestation_cont (struct GNUNET_REST_RequestHandle *con_handle,
   GNUNET_free (identity_id_str);
 }
 
+
 /**
  * List tickets for identity request
  *
@@ -1173,7 +854,7 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   const char *identity;
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
-  struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attribute;
+  struct GNUNET_RECLAIM_Attribute *attribute;
   struct GNUNET_TIME_Relative exp;
   char term_data[handle->rest_handle->data_size + 1];
   json_t *data_json;
@@ -1242,20 +923,21 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   GNUNET_JSON_parse_free (attrspec);
 }
 
+
 /**
  * Parse a JWT and return the respective claim value as Attribute
  *
  * @param attest the jwt attestation
  * @param claim the name of the claim in the JWT
  *
- * @return a GNUNET_RECLAIM_ATTRIBUTE_Claim, containing the new value
+ * @return a GNUNET_RECLAIM_Attribute, containing the new value
  */
-struct GNUNET_RECLAIM_ATTRIBUTE_Claim *
-parse_jwt (const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
+struct GNUNET_RECLAIM_Attribute *
+parse_jwt (const struct GNUNET_RECLAIM_Attestation *attest,
            const char *claim)
 {
   char *jwt_string;
-  struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr;
+  struct GNUNET_RECLAIM_Attribute *attr;
   char delim[] = ".";
   const char *type_str = NULL;
   const char *val_str = NULL;
@@ -1267,7 +949,7 @@ parse_jwt (const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
   json_t *json_val;
   json_error_t *json_err = NULL;
 
-  jwt_string = GNUNET_RECLAIM_ATTESTATION_value_to_string (attest->type,
+  jwt_string = GNUNET_RECLAIM_attestation_value_to_string (attest->type,
                                                            attest->data,
                                                            attest->data_size);
   char *jwt_body = strtok (jwt_string, delim);
@@ -1284,24 +966,26 @@ parse_jwt (const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
     }
   }
   type_str = "String";
-  type = GNUNET_RECLAIM_ATTRIBUTE_typename_to_number (type_str);
-  if (GNUNET_SYSERR ==(GNUNET_RECLAIM_ATTRIBUTE_string_to_value (type,val_str,
+  type = GNUNET_RECLAIM_attribute_typename_to_number (type_str);
+  if (GNUNET_SYSERR == GNUNET_RECLAIM_attribute_string_to_value (type,val_str,
                                                                  (void **) &data,
-                                                                 &data_size)))
+                                                                 &data_size))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Attribute value from JWT Parser invalid!\n");
-    GNUNET_RECLAIM_ATTRIBUTE_string_to_value (type,
+    GNUNET_RECLAIM_attribute_string_to_value (type,
                                               "Error: Referenced Claim Name not Found",
                                               (void **) &data,
                                               &data_size);
-    attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (claim, type, data, data_size);
+    attr = GNUNET_RECLAIM_attribute_new (claim, &attest->id,
+                                         type, data, data_size);
     attr->id = attest->id;
     attr->flag = 1;
   }
   else
   {
-    attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (claim, type, data, data_size);
+    attr = GNUNET_RECLAIM_attribute_new (claim, &attest->id,
+                                         type, data, data_size);
     attr->id = attest->id;
     attr->flag = 1;
   }
@@ -1316,53 +1000,34 @@ parse_jwt (const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
 static void
 attr_collect (void *cls,
               const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-              const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr,
-              const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
-              const struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *reference)
+              const struct GNUNET_RECLAIM_Attribute *attr,
+              const struct GNUNET_RECLAIM_Attestation *attest)
 {
   struct RequestHandle *handle = cls;
   json_t *attr_obj;
   const char *type;
   char *id_str;
 
-  if ((NULL == attr) && (NULL == reference))
+  if (GNUNET_NO == GNUNET_RECLAIM_id_is_zero (&attr->attestation))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Attribute Collection with empty Attribute/Reference\n");
-    GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
-    return;
-  }
-
-  if (NULL == attr)
-  {
-
-    if ((NULL == reference->name) || (NULL == reference->reference_value))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Attribute Collection with empty Reference Name/Value\n");
-      return;
-    }
-    struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr2;
-    attr2 = parse_jwt (attest, reference->reference_value);
+    struct GNUNET_RECLAIM_Attribute *attr2;
+    attr2 = parse_jwt (attest, attr->data);
     if (NULL == attr2)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Attribute Collection with unparsed Attestation\n");
       return;
     }
-    attr2->name = reference->name;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding reference as attribute: %s\n",
-                reference->name);
+    attr2->name = attr->name;
     char *tmp_value;
-    tmp_value = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr2->type,
+    tmp_value = GNUNET_RECLAIM_attribute_value_to_string (attr2->type,
                                                           attr2->data,
                                                           attr2->data_size);
     attr_obj = json_object ();
-
     json_object_set_new (attr_obj, "value", json_string (tmp_value));
     json_object_set_new (attr_obj, "name", json_string (attr2->name));
     json_object_set_new (attr_obj, "flag", json_string ("1"));
-    type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr2->type);
+    type = GNUNET_RECLAIM_attribute_number_to_typename (attr2->type);
     json_object_set_new (attr_obj, "type", json_string (type));
     id_str = GNUNET_STRINGS_data_to_string_alloc (&attr2->id,
                                                   sizeof(attr2->id));
@@ -1373,18 +1038,11 @@ attr_collect (void *cls,
   }
   else
   {
-    if ((NULL == attr->name) || (NULL == attr->data))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Attribute Collection with empty Attribute Name/Value\n");
-      GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
-      return;
-    }
     char *tmp_value;
     char *flag_str;
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
 
-    tmp_value = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
+    tmp_value = GNUNET_RECLAIM_attribute_value_to_string (attr->type,
                                                           attr->data,
                                                           attr->data_size);
 
@@ -1393,7 +1051,7 @@ attr_collect (void *cls,
     json_object_set_new (attr_obj, "name", json_string (attr->name));
     GNUNET_asprintf (&flag_str,"%d",attr->flag);
     json_object_set_new (attr_obj, "flag", json_string (flag_str));
-    type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
+    type = GNUNET_RECLAIM_attribute_number_to_typename (attr->type);
     json_object_set_new (attr_obj, "type", json_string (type));
     id_str = GNUNET_STRINGS_data_to_string_alloc (&attr->id,
                                                   sizeof(attr->id));
@@ -1405,6 +1063,7 @@ attr_collect (void *cls,
   }
 }
 
+
 /**
  * List attributes for identity request
  *
@@ -1474,7 +1133,7 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
   struct RequestHandle *handle = cls;
-  struct GNUNET_RECLAIM_ATTRIBUTE_Claim attr;
+  struct GNUNET_RECLAIM_Attribute attr;
   struct EgoEntry *ego_entry;
   char *identity_id_str;
   char *identity;
@@ -1514,7 +1173,7 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   }
   priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   handle->idp = GNUNET_RECLAIM_connect (cfg);
-  memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_ATTRIBUTE_Claim));
+  memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_Attribute));
   GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof(attr.id));
   attr.name = "";
   handle->idp_op = GNUNET_RECLAIM_attribute_delete (handle->idp,
@@ -1603,9 +1262,8 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
 static void
 consume_cont (void *cls,
               const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-              const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr,
-              const struct GNUNET_RECLAIM_ATTESTATION_Claim *attest,
-              const struct GNUNET_RECLAIM_ATTESTATION_REFERENCE *reference)
+              const struct GNUNET_RECLAIM_Attribute *attr,
+              const struct GNUNET_RECLAIM_Attestation *attest)
 {
   struct RequestHandle *handle = cls;
   char *val_str;
@@ -1618,7 +1276,7 @@ consume_cont (void *cls,
   }
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
-  val_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
+  val_str = GNUNET_RECLAIM_attribute_value_to_string (attr->type,
                                                       attr->data,
                                                       attr->data_size);
   if (NULL == val_str)
@@ -1749,13 +1407,13 @@ init_cont (struct RequestHandle *handle)
       GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
       &delete_attribute_cont },
     { MHD_HTTP_METHOD_GET,
-      GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE,
+      GNUNET_REST_API_NS_RECLAIM_ATTESTATION,
       &list_attestation_cont },
     { MHD_HTTP_METHOD_POST,
-      GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE,
+      GNUNET_REST_API_NS_RECLAIM_ATTESTATION,
       &add_attestation_cont },
     { MHD_HTTP_METHOD_DELETE,
-      GNUNET_REST_API_NS_RECLAIM_ATTESTATION_REFERENCE,
+      GNUNET_REST_API_NS_RECLAIM_ATTESTATION,
       &delete_attestation_cont },
     { MHD_HTTP_METHOD_GET,
       GNUNET_REST_API_NS_IDENTITY_TICKETS,