RECLAIM/REST: add attribute ID to JSON

2 files changed, 241 insertions, 402 deletions

diff --git a/src/reclaim/json_reclaim.c b/src/reclaim/json_reclaim.c
index 0fe9150d9..79110490a 100644
--- a/src/reclaim/json_reclaim.c
+++ b/src/reclaim/json_reclaim.c
@@ -24,10 +24,13 @@
  * @author Martin Schanzenbach
  */
 #include "platform.h"
+
 #include "gnunet_util_lib.h"
+
 #include "gnunet_json_lib.h"
-#include "gnunet_reclaim_service.h"
 #include "gnunet_reclaim_attribute_lib.h"
+#include "gnunet_reclaim_service.h"
+
 
 /**
  * Parse given JSON object to a claim
@@ -38,54 +41,48 @@
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
 static int
-parse_attr (void *cls,
-              json_t *root,
-              struct GNUNET_JSON_Specification *spec)
+parse_attr (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
 {
   struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr;
-  const char* name_str;
-  const char* val_str;
-  const char* type_str;
+  const char *name_str;
+  const char *val_str;
+  const char *type_str;
+  const char *id_str;
   char *data;
   int unpack_state;
   uint32_t type;
   size_t data_size;
 
-  GNUNET_assert(NULL != root);
+  GNUNET_assert (NULL != root);
 
-  if(!json_is_object(root))
-  {
+  if (!json_is_object (root)) {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Error json is not array nor object!\n");
     return GNUNET_SYSERR;
   }
-  //interpret single attribute
-  unpack_state = json_unpack(root,
-                             "{s:s, s:s, s:s!}",
-                             "name", &name_str,
-                             "type", &type_str,
-                             "value", &val_str);
-  if (0 != unpack_state)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Error json object has a wrong format!\n");
+  // interpret single attribute
+  unpack_state =
+      json_unpack (root, "{s:s, s:s, s:s, s:s!}", "name", &name_str, "id",
+                   &id_str, "type", &type_str, "value", &val_str);
+  if (0 != unpack_state) {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error json object has a wrong format!\n");
     return GNUNET_SYSERR;
   }
   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)))
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Attribute value invalid!\n");
+  if (GNUNET_SYSERR == (GNUNET_RECLAIM_ATTRIBUTE_string_to_value (
+                           type, val_str, (void **)&data, &data_size))) {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Attribute value invalid!\n");
     return GNUNET_SYSERR;
   }
-  attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (name_str,
-                                             type,
-                                             data,
-                                             data_size);
-  *(struct GNUNET_RECLAIM_ATTRIBUTE_Claim **) spec->ptr = attr;
+  attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (name_str, type, data, data_size);
+  if (0 == strlen (id_str))
+    attr->id = 0;
+  else
+    GNUNET_STRINGS_string_to_data (id_str, strlen (id_str), &attr->id,
+                                   sizeof (uint64_t));
+
+  *(struct GNUNET_RECLAIM_ATTRIBUTE_Claim **)spec->ptr = attr;
   return GNUNET_OK;
 }
 
@@ -99,10 +96,9 @@ static void
 clean_attr (void *cls, struct GNUNET_JSON_Specification *spec)
 {
   struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr;
-  attr = (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **) spec->ptr;
-  if (NULL != *attr)
-  {
-    GNUNET_free(*attr);
+  attr = (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **)spec->ptr;
+  if (NULL != *attr) {
+    GNUNET_free (*attr);
     *attr = NULL;
   }
 }
@@ -116,15 +112,13 @@ clean_attr (void *cls, struct GNUNET_JSON_Specification *spec)
 struct GNUNET_JSON_Specification
 GNUNET_RECLAIM_JSON_spec_claim (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr)
 {
-  struct GNUNET_JSON_Specification ret = {
-    .parser = &parse_attr,
-    .cleaner = &clean_attr,
-    .cls = NULL,
-    .field = NULL,
-    .ptr = attr,
-    .ptr_size = 0,
-    .size_ptr = NULL
-  };
+  struct GNUNET_JSON_Specification ret = {.parser = &parse_attr,
+                                          .cleaner = &clean_attr,
+                                          .cls = NULL,
+                                          .field = NULL,
+                                          .ptr = attr,
+                                          .ptr_size = 0,
+                                          .size_ptr = NULL};
   *attr = NULL;
   return ret;
 }
@@ -137,67 +131,54 @@ GNUNET_RECLAIM_JSON_spec_claim (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr)
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
 static int
-parse_ticket (void *cls,
-              json_t *root,
-              struct GNUNET_JSON_Specification *spec)
+parse_ticket (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
 {
   struct GNUNET_RECLAIM_Ticket *ticket;
-  const char* rnd_str;
-  const char* aud_str;
-  const char* id_str;
+  const char *rnd_str;
+  const char *aud_str;
+  const char *id_str;
   int unpack_state;
 
-  GNUNET_assert(NULL != root);
+  GNUNET_assert (NULL != root);
 
-  if(!json_is_object(root))
-  {
+  if (!json_is_object (root)) {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Error json is not array nor object!\n");
     return GNUNET_SYSERR;
   }
-  //interpret single ticket
-  unpack_state = json_unpack(root,
-                             "{s:s, s:s, s:s!}",
-                             "rnd", &rnd_str,
-                             "audience", &aud_str,
-                             "identity", &id_str);
-  if (0 != unpack_state)
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Error json object has a wrong format!\n");
+  // interpret single ticket
+  unpack_state = json_unpack (root, "{s:s, s:s, s:s!}", "rnd", &rnd_str,
+                              "audience", &aud_str, "identity", &id_str);
+  if (0 != unpack_state) {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error json object has a wrong format!\n");
     return GNUNET_SYSERR;
   }
   ticket = GNUNET_new (struct GNUNET_RECLAIM_Ticket);
-  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (rnd_str,
-                                                  strlen (rnd_str),
+  if (GNUNET_OK != GNUNET_STRINGS_string_to_data (rnd_str, strlen (rnd_str),
                                                   &ticket->rnd,
-                                                  sizeof (uint64_t)))
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Rnd invalid\n");
-    GNUNET_free(ticket);
+                                                  sizeof (uint64_t))) {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Rnd invalid\n");
+    GNUNET_free (ticket);
     return GNUNET_SYSERR;
   }
-  GNUNET_STRINGS_string_to_data (id_str,
-                                 strlen (id_str),
-                                 &ticket->identity,
+  GNUNET_STRINGS_string_to_data (id_str, strlen (id_str), &ticket->identity,
                                  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Identity invalid\n");
-    GNUNET_free(ticket);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity invalid\n");
+    GNUNET_free (ticket);
     return GNUNET_SYSERR;
   }
 
-  GNUNET_STRINGS_string_to_data (aud_str,
-                                 strlen (aud_str),
-                                 &ticket->audience,
+  GNUNET_STRINGS_string_to_data (aud_str, strlen (aud_str), &ticket->audience,
                                  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Audience invalid\n");
-    GNUNET_free(ticket);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Audience invalid\n");
+    GNUNET_free (ticket);
     return GNUNET_SYSERR;
   }
 
-  *(struct GNUNET_RECLAIM_Ticket **) spec->ptr = ticket;
+  *(struct GNUNET_RECLAIM_Ticket **)spec->ptr = ticket;
   return GNUNET_OK;
 }
 
@@ -211,10 +192,9 @@ static void
 clean_ticket (void *cls, struct GNUNET_JSON_Specification *spec)
 {
   struct GNUNET_RECLAIM_Ticket **ticket;
-  ticket = (struct GNUNET_RECLAIM_Ticket **) spec->ptr;
-  if (NULL != *ticket)
-  {
-    GNUNET_free(*ticket);
+  ticket = (struct GNUNET_RECLAIM_Ticket **)spec->ptr;
+  if (NULL != *ticket) {
+    GNUNET_free (*ticket);
     *ticket = NULL;
   }
 }
@@ -228,15 +208,13 @@ clean_ticket (void *cls, struct GNUNET_JSON_Specification *spec)
 struct GNUNET_JSON_Specification
 GNUNET_RECLAIM_JSON_spec_ticket (struct GNUNET_RECLAIM_Ticket **ticket)
 {
-  struct GNUNET_JSON_Specification ret = {
-    .parser = &parse_ticket,
-    .cleaner = &clean_ticket,
-    .cls = NULL,
-    .field = NULL,
-    .ptr = ticket,
-    .ptr_size = 0,
-    .size_ptr = NULL
-  };
+  struct GNUNET_JSON_Specification ret = {.parser = &parse_ticket,
+                                          .cleaner = &clean_ticket,
+                                          .cls = NULL,
+                                          .field = NULL,
+                                          .ptr = ticket,
+                                          .ptr_size = 0,
+                                          .size_ptr = NULL};
   *ticket = NULL;
   return ret;
 }
diff --git a/src/reclaim/plugin_rest_reclaim.c b/src/reclaim/plugin_rest_reclaim.c
index b36ed2bb6..ae46211d5 100644
--- a/src/reclaim/plugin_rest_reclaim.c
+++ b/src/reclaim/plugin_rest_reclaim.c
@@ -11,7 +11,7 @@
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Affero General Public License for more details.
-  
+
    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -24,22 +24,22 @@
  * @brief GNUnet reclaim REST plugin
  *
  */
-
 #include "platform.h"
-#include "gnunet_rest_plugin.h"
-#include "gnunet_identity_service.h"
+
+#include "microhttpd.h"
+#include <inttypes.h>
+#include <jansson.h>
+
 #include "gnunet_gns_service.h"
 #include "gnunet_gnsrecord_lib.h"
+#include "gnunet_identity_service.h"
 #include "gnunet_namestore_service.h"
-#include "gnunet_rest_lib.h"
-#include "microhttpd.h"
-#include <jansson.h>
-#include <inttypes.h>
-#include "gnunet_signatures.h"
 #include "gnunet_reclaim_attribute_lib.h"
 #include "gnunet_reclaim_service.h"
+#include "gnunet_rest_lib.h"
+#include "gnunet_rest_plugin.h"
+#include "gnunet_signatures.h"
 #include "json_reclaim.h"
-
 /**
  * REST root namespace
  */
@@ -83,7 +83,7 @@ const struct GNUNET_CONFIGURATION_Handle *cfg;
 /**
  * HTTP methods allows for this plugin
  */
-static char* allow_methods;
+static char *allow_methods;
 
 /**
  * @brief struct returned by the initialization function of the plugin
@@ -246,7 +246,6 @@ struct RequestHandle
    * Response object
    */
   json_t *resp_object;
-
 };
 
 /**
@@ -260,8 +259,7 @@ cleanup_handle (struct RequestHandle *handle)
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_tmp;
   struct EgoEntry *ego_entry;
   struct EgoEntry *ego_tmp;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Cleaning up\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
   if (NULL != handle->resp_object)
     json_decref (handle->resp_object);
   if (NULL != handle->timeout_task)
@@ -280,30 +278,24 @@ cleanup_handle (struct RequestHandle *handle)
     GNUNET_free (handle->emsg);
   if (NULL != handle->namestore_handle)
     GNUNET_NAMESTORE_disconnect (handle->namestore_handle);
-  if ( NULL != handle->attr_list )
-  {
-    for (claim_entry = handle->attr_list->list_head;
-    NULL != claim_entry;)
-    {
+  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);
+      GNUNET_free (claim_tmp->claim);
+      GNUNET_free (claim_tmp);
     }
     GNUNET_free (handle->attr_list);
   }
-  for (ego_entry = handle->ego_head;
-       NULL != ego_entry;)
-  {
+  for (ego_entry = handle->ego_head; NULL != ego_entry;) {
     ego_tmp = ego_entry;
     ego_entry = ego_entry->next;
     GNUNET_free (ego_tmp->identifier);
     GNUNET_free (ego_tmp->keystring);
     GNUNET_free (ego_tmp);
   }
-  if (NULL != handle->attr_it)
-  {
-    GNUNET_free(handle->attr_it);
+  if (NULL != handle->attr_it) {
+    GNUNET_free (handle->attr_it);
   }
   GNUNET_free (handle);
 }
@@ -327,10 +319,8 @@ do_error (void *cls)
   struct MHD_Response *resp;
   char *json_error;
 
-  GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }",
-                   handle->emsg);
-  if ( 0 == handle->response_code )
-  {
+  GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
+  if (0 == handle->response_code) {
     handle->response_code = MHD_HTTP_BAD_REQUEST;
   }
   resp = GNUNET_REST_create_response (json_error);
@@ -365,16 +355,13 @@ collect_error_cb (void *cls)
 }
 
 static void
-finished_cont (void *cls,
-               int32_t success,
-               const char *emsg)
+finished_cont (void *cls, int32_t success, const char *emsg)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
 
   resp = GNUNET_REST_create_response (emsg);
-  if (GNUNET_OK != success)
-  {
+  if (GNUNET_OK != success) {
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -391,7 +378,7 @@ finished_cont (void *cls,
 static void
 return_response (void *cls)
 {
-  char* result_str;
+  char *result_str;
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
 
@@ -407,7 +394,7 @@ static void
 collect_finished_cb (void *cls)
 {
   struct RequestHandle *handle = cls;
-  //Done
+  // Done
   handle->attr_it = NULL;
   handle->ticket_it = NULL;
   GNUNET_SCHEDULER_add_now (&return_response, handle);
@@ -419,48 +406,37 @@ collect_finished_cb (void *cls)
  *
  */
 static void
-ticket_collect (void *cls,
-                const struct GNUNET_RECLAIM_Ticket *ticket)
+ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 {
   json_t *json_resource;
   struct RequestHandle *handle = cls;
   json_t *value;
-  char* tmp;
+  char *tmp;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding ticket\n");
-  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd,
-                                             sizeof (uint64_t));
+  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t));
   json_resource = json_object ();
   GNUNET_free (tmp);
-  json_array_append (handle->resp_object,
-                     json_resource);
+  json_array_append (handle->resp_object, json_resource);
 
-  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->identity,
-                                             sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+  tmp = GNUNET_STRINGS_data_to_string_alloc (
+      &ticket->identity, sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
   value = json_string (tmp);
-  json_object_set_new (json_resource,
-                       "issuer",
-                       value);
+  json_object_set_new (json_resource, "issuer", value);
   GNUNET_free (tmp);
-  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->audience,
-                                             sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
+  tmp = GNUNET_STRINGS_data_to_string_alloc (
+      &ticket->audience, sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
   value = json_string (tmp);
-  json_object_set_new (json_resource,
-                       "audience",
-                       value);
+  json_object_set_new (json_resource, "audience", value);
   GNUNET_free (tmp);
-  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd,
-                                             sizeof (uint64_t));
+  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t));
   value = json_string (tmp);
-  json_object_set_new (json_resource,
-                       "rnd",
-                       value);
+  json_object_set_new (json_resource, "rnd", value);
   GNUNET_free (tmp);
   GNUNET_RECLAIM_ticket_iteration_next (handle->ticket_it);
 }
 
 
-
 /**
  * List tickets for identity request
  *
@@ -470,8 +446,7 @@ ticket_collect (void *cls,
  */
 static void
 list_tickets_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                   const char* url,
-                   void *cls)
+                   const char *url, void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
   struct RequestHandle *handle = cls;
@@ -480,172 +455,138 @@ list_tickets_cont (struct GNUNET_REST_RequestHandle *con_handle,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting tickets for %s.\n",
               handle->url);
-  if ( strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) >=
-       strlen (handle->url))
-  {
+  if (strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) >= 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_IDENTITY_TICKETS) + 1;
 
-  for (ego_entry = handle->ego_head;
-       NULL != ego_entry;
+  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);
+  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->ticket_it = GNUNET_RECLAIM_ticket_iteration_start (handle->idp,
-                                                             priv_key,
-                                                             &collect_error_cb,
-                                                             handle,
-                                                             &ticket_collect,
-                                                             handle,
-                                                             &collect_finished_cb,
-                                                             handle);
+  handle->ticket_it = GNUNET_RECLAIM_ticket_iteration_start (
+      handle->idp, priv_key, &collect_error_cb, handle, &ticket_collect, handle,
+      &collect_finished_cb, handle);
 }
 
 
 static void
 add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                    const char* url,
-                    void *cls)
+                    const char *url, void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
-  const char* identity;
+  const char *identity;
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attribute;
   struct GNUNET_TIME_Relative exp;
-  char term_data[handle->rest_handle->data_size+1];
+  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 (&attribute),
-    GNUNET_JSON_spec_end()
-  };
+      GNUNET_RECLAIM_JSON_spec_claim (&attribute), GNUNET_JSON_spec_end ()};
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding an attribute for %s.\n",
               handle->url);
-  if ( strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >=
-       strlen (handle->url))
-  {
+  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= 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_ATTRIBUTES) + 1;
 
-  for (ego_entry = handle->ego_head;
-       NULL != ego_entry;
+  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);
+  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)
-  {
+  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,
+  GNUNET_memcpy (term_data, handle->rest_handle->data,
                  handle->rest_handle->data_size);
-  data_json = json_loads (term_data,
-                          JSON_DECODE_ANY,
-                          &err);
+  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_JSON_parse (data_json, attrspec,
-                                    NULL, NULL));
+                 GNUNET_JSON_parse (data_json, attrspec, NULL, NULL));
   json_decref (data_json);
-  if (NULL == attribute)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse attribute from %s\n",
+  if (NULL == attribute) {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to parse attribute from %s\n",
                 term_data);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
+  /**
+   * New ID for attribute
+   */
+  attribute->id =
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
   handle->idp = GNUNET_RECLAIM_connect (cfg);
   exp = GNUNET_TIME_UNIT_HOURS;
-  handle->idp_op = GNUNET_RECLAIM_attribute_store (handle->idp,
-                                                   identity_priv,
-                                                   attribute,
-                                                   &exp,
-                                                   &finished_cont,
-                                                   handle);
+  handle->idp_op = GNUNET_RECLAIM_attribute_store (
+      handle->idp, identity_priv, attribute, &exp, &finished_cont, handle);
   GNUNET_JSON_parse_free (attrspec);
 }
 
 
-
 /**
  * Collect all attributes for an ego
  *
  */
 static void
-attr_collect (void *cls,
-              const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+attr_collect (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
               const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 {
   struct RequestHandle *handle = cls;
   json_t *attr_obj;
-  const char* type;
-  char* tmp_value;
+  const char *type;
+  char *tmp_value;
+  char *id_str;
 
-  if ((NULL == attr->name) || (NULL == attr->data))
-  {
+  if ((NULL == attr->name) || (NULL == attr->data)) {
     GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
     return;
   }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n",
-              attr->name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
 
-  tmp_value = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
-                                                        attr->data,
+  tmp_value = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type, attr->data,
                                                         attr->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 (attr->name));
+  json_object_set_new (attr_obj, "value", json_string (tmp_value));
+  json_object_set_new (attr_obj, "name", json_string (attr->name));
   type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
-  json_object_set_new (attr_obj,
-                       "type",
-                       json_string (type));
-  json_array_append (handle->resp_object,
-                     attr_obj);
+  json_object_set_new (attr_obj, "type", json_string (type));
+  id_str = GNUNET_STRINGS_data_to_string_alloc (&attr->id, sizeof (uint64_t));
+  json_object_set_new (attr_obj, "id", json_string (id_str));
+  json_array_append (handle->resp_object, attr_obj);
   json_decref (attr_obj);
-  GNUNET_free(tmp_value);
+  GNUNET_free (tmp_value);
   GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
 }
 
 
-
 /**
  * List attributes for identity request
  *
@@ -655,8 +596,7 @@ attr_collect (void *cls,
  */
 static void
 list_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                     const char* url,
-                     void *cls)
+                     const char *url, void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
   struct RequestHandle *handle = cls;
@@ -665,91 +605,68 @@ list_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting attributes for %s.\n",
               handle->url);
-  if ( strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >=
-       strlen (handle->url))
-  {
+  if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= 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_ATTRIBUTES) + 1;
 
-  for (ego_entry = handle->ego_head;
-       NULL != ego_entry;
+  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);
+  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,
-                                                         &attr_collect,
-                                                         handle,
-                                                         &collect_finished_cb,
-                                                         handle);
+  handle->attr_it = GNUNET_RECLAIM_get_attributes_start (
+      handle->idp, priv_key, &collect_error_cb, handle, &attr_collect, handle,
+      &collect_finished_cb, handle);
 }
 
 
 static void
 revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                    const char* url,
-                    void *cls)
+                    const char *url, void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct GNUNET_RECLAIM_Ticket *ticket;
   struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
-  char term_data[handle->rest_handle->data_size+1];
+  char term_data[handle->rest_handle->data_size + 1];
   json_t *data_json;
   json_error_t err;
   struct GNUNET_JSON_Specification tktspec[] = {
-    GNUNET_RECLAIM_JSON_spec_ticket (&ticket),
-    GNUNET_JSON_spec_end()
-  };
+      GNUNET_RECLAIM_JSON_spec_ticket (&ticket), GNUNET_JSON_spec_end ()};
 
-  if (0 >= handle->rest_handle->data_size)
-  {
+  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,
+  GNUNET_memcpy (term_data, handle->rest_handle->data,
                  handle->rest_handle->data_size);
-  data_json = json_loads (term_data,
-                          JSON_DECODE_ANY,
-                          &err);
+  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_JSON_parse (data_json, tktspec,
-                                    NULL, NULL));
+                 GNUNET_JSON_parse (data_json, tktspec, NULL, NULL));
   json_decref (data_json);
-  if (NULL == ticket)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse ticket from %s\n",
+  if (NULL == ticket) {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to parse ticket from %s\n",
                 term_data);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  if (GNUNET_OK != GNUNET_JSON_parse (data_json,
-                                      tktspec,
-                                      NULL, NULL))
-  {
+  if (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL)) {
     handle->emsg = GNUNET_strdup ("Not a ticket!\n");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     GNUNET_JSON_parse_free (tktspec);
@@ -757,149 +674,111 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
     return;
   }
 
-  for (ego_entry = handle->ego_head;
-       NULL != ego_entry;
-       ego_entry = ego_entry->next)
-  {
-    GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego,
-                                        &tmp_pk);
-    if (0 == memcmp (&ticket->identity,
-                     &tmp_pk,
+  for (ego_entry = handle->ego_head; NULL != ego_entry;
+       ego_entry = ego_entry->next) {
+    GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
+    if (0 == memcmp (&ticket->identity, &tmp_pk,
                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
       break;
   }
-  if (NULL == ego_entry)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Identity unknown\n");
+  if (NULL == ego_entry) {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
     GNUNET_JSON_parse_free (tktspec);
     return;
   }
   identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
 
   handle->idp = GNUNET_RECLAIM_connect (cfg);
-  handle->idp_op = GNUNET_RECLAIM_ticket_revoke (handle->idp,
-                                                 identity_priv,
-                                                 ticket,
-                                                 &finished_cont,
-                                                 handle);
+  handle->idp_op = GNUNET_RECLAIM_ticket_revoke (
+      handle->idp, identity_priv, ticket, &finished_cont, handle);
   GNUNET_JSON_parse_free (tktspec);
 }
 
 static void
-consume_cont (void *cls,
-              const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+consume_cont (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
               const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 {
   struct RequestHandle *handle = cls;
   char *val_str;
   json_t *value;
 
-  if (NULL == identity)
-  {
+  if (NULL == identity) {
     GNUNET_SCHEDULER_add_now (&return_response, handle);
     return;
   }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n",
-              attr->name);
-  val_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
-                                                      attr->data,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
+  val_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type, attr->data,
                                                       attr->data_size);
-  if (NULL == val_str)
-  {
+  if (NULL == val_str) {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to parse value for: %s\n",
                 attr->name);
     return;
   }
-  value = json_string(val_str);
-  json_object_set_new (handle->resp_object,
-                       attr->name,
-                       value);
+  value = json_string (val_str);
+  json_object_set_new (handle->resp_object, attr->name, value);
   json_decref (value);
   GNUNET_free (val_str);
 }
 
 static void
 consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                     const char* url,
-                     void *cls)
+                     const char *url, void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct GNUNET_RECLAIM_Ticket *ticket;
   struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
-  char term_data[handle->rest_handle->data_size+1];
+  char term_data[handle->rest_handle->data_size + 1];
   json_t *data_json;
   json_error_t err;
   struct GNUNET_JSON_Specification tktspec[] = {
-    GNUNET_RECLAIM_JSON_spec_ticket (&ticket),
-    GNUNET_JSON_spec_end ()
-  };
+      GNUNET_RECLAIM_JSON_spec_ticket (&ticket), GNUNET_JSON_spec_end ()};
 
-  if (0 >= handle->rest_handle->data_size)
-  {
+  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,
+  GNUNET_memcpy (term_data, handle->rest_handle->data,
                  handle->rest_handle->data_size);
-  data_json = json_loads (term_data,
-                          JSON_DECODE_ANY,
-                          &err);
-  if (NULL == data_json)
-  {
+  data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
+  if (NULL == data_json) {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to parse JSON Object from %s\n",
-                term_data);
+                "Unable to parse JSON Object from %s\n", term_data);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  if (GNUNET_OK != GNUNET_JSON_parse (data_json,
-                                      tktspec,
-                                      NULL, NULL))
-  {
+  if (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL)) {
     handle->emsg = GNUNET_strdup ("Not a ticket!\n");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
-    GNUNET_JSON_parse_free(tktspec);
+    GNUNET_JSON_parse_free (tktspec);
     json_decref (data_json);
     return;
   }
-  for (ego_entry = handle->ego_head;
-       NULL != ego_entry;
-       ego_entry = ego_entry->next)
-  {
-    GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego,
-                                        &tmp_pk);
-    if (0 == memcmp (&ticket->audience,
-                     &tmp_pk,
+  for (ego_entry = handle->ego_head; NULL != ego_entry;
+       ego_entry = ego_entry->next) {
+    GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
+    if (0 == memcmp (&ticket->audience, &tmp_pk,
                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
       break;
   }
-  if (NULL == ego_entry)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Identity unknown\n");
+  if (NULL == ego_entry) {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
     GNUNET_JSON_parse_free (tktspec);
     return;
   }
   identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
   handle->resp_object = json_object ();
   handle->idp = GNUNET_RECLAIM_connect (cfg);
-  handle->idp_op = GNUNET_RECLAIM_ticket_consume (handle->idp,
-                                                  identity_priv,
-                                                  ticket,
-                                                  &consume_cont,
-                                                  handle);
+  handle->idp_op = GNUNET_RECLAIM_ticket_consume (
+      handle->idp, identity_priv, ticket, &consume_cont, handle);
   GNUNET_JSON_parse_free (tktspec);
 }
 
 
-
 /**
  * Respond to OPTIONS request
  *
@@ -908,18 +787,15 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
  * @param cls the RequestHandle
  */
 static void
-options_cont (struct GNUNET_REST_RequestHandle *con_handle,
-              const char* url,
+options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url,
               void *cls)
 {
   struct MHD_Response *resp;
   struct RequestHandle *handle = cls;
 
-  //For now, independent of path return all options
+  // For now, independent of path return all options
   resp = GNUNET_REST_create_response (NULL);
-  MHD_add_response_header (resp,
-                           "Access-Control-Allow-Methods",
-                           allow_methods);
+  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
   cleanup_handle (handle);
   return;
@@ -935,21 +811,21 @@ init_cont (struct RequestHandle *handle)
 {
   struct GNUNET_REST_RequestHandlerError err;
   static const struct GNUNET_REST_RequestHandler handlers[] = {
-    {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &list_attribute_cont},
-    {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, &add_attribute_cont},
-    {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_TICKETS, &list_tickets_cont},
-    {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_REVOKE, &revoke_ticket_cont},
-    {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_CONSUME, &consume_ticket_cont},
-    {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM,
-      &options_cont},
-    GNUNET_REST_HANDLER_END
-  };
-
-  if (GNUNET_NO == GNUNET_REST_handle_request (handle->rest_handle,
-                                               handlers,
-                                               &err,
-                                               handle))
-  {
+      {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+       &list_attribute_cont},
+      {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+       &add_attribute_cont},
+      {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_TICKETS,
+       &list_tickets_cont},
+      {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_REVOKE,
+       &revoke_ticket_cont},
+      {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_CONSUME,
+       &consume_ticket_cont},
+      {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM, &options_cont},
+      GNUNET_REST_HANDLER_END};
+
+  if (GNUNET_NO == GNUNET_REST_handle_request (handle->rest_handle, handlers,
+                                               &err, handle)) {
     handle->response_code = err.error_code;
     GNUNET_SCHEDULER_add_now (&do_error, handle);
   }
@@ -989,17 +865,14 @@ init_cont (struct RequestHandle *handle)
  *                   must thus no longer be used
  */
 static void
-list_ego (void *cls,
-          struct GNUNET_IDENTITY_Ego *ego,
-          void **ctx,
+list_ego (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
           const char *identifier)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
 
-  if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
-  {
+  if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state)) {
     handle->state = ID_REST_STATE_POST_INIT;
     init_cont (handle);
     return;
@@ -1007,19 +880,17 @@ list_ego (void *cls,
   if (ID_REST_STATE_INIT == handle->state) {
     ego_entry = GNUNET_new (struct EgoEntry);
     GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
-    ego_entry->keystring =
-      GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
+    ego_entry->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
     ego_entry->ego = ego;
     ego_entry->identifier = GNUNET_strdup (identifier);
-    GNUNET_CONTAINER_DLL_insert_tail(handle->ego_head,handle->ego_tail, ego_entry);
+    GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head, handle->ego_tail,
+                                      ego_entry);
   }
-
 }
 
 static void
-rest_identity_process_request(struct GNUNET_REST_RequestHandle *rest_handle,
-                              GNUNET_REST_ResultProcessor proc,
-                              void *proc_cls)
+rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
+                               GNUNET_REST_ResultProcessor proc, void *proc_cls)
 {
   struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
   handle->response_code = 0;
@@ -1030,20 +901,14 @@ rest_identity_process_request(struct GNUNET_REST_RequestHandle *rest_handle,
   handle->rest_handle = rest_handle;
 
   handle->url = GNUNET_strdup (rest_handle->url);
-  if (handle->url[strlen (handle->url)-1] == '/')
-    handle->url[strlen (handle->url)-1] = '\0';
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connecting...\n");
-  handle->identity_handle = GNUNET_IDENTITY_connect (cfg,
-                                                     &list_ego,
-                                                     handle);
+  if (handle->url[strlen (handle->url) - 1] == '/')
+    handle->url[strlen (handle->url) - 1] = '\0';
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
+  handle->identity_handle = GNUNET_IDENTITY_connect (cfg, &list_ego, handle);
   handle->namestore_handle = GNUNET_NAMESTORE_connect (cfg);
   handle->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (handle->timeout,
-                                  &do_timeout,
-                                  handle);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connected\n");
+      GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_timeout, handle);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
 }
 
 /**
@@ -1060,23 +925,19 @@ libgnunet_plugin_rest_reclaim_init (void *cls)
 
   cfg = cls;
   if (NULL != plugin.cfg)
-    return NULL;                /* can only initialize once! */
+    return NULL; /* can only initialize once! */
   memset (&plugin, 0, sizeof (struct Plugin));
   plugin.cfg = cfg;
   api = GNUNET_new (struct GNUNET_REST_Plugin);
   api->cls = &plugin;
   api->name = GNUNET_REST_API_NS_RECLAIM;
   api->process_request = &rest_identity_process_request;
-  GNUNET_asprintf (&allow_methods,
-                   "%s, %s, %s, %s, %s",
-                   MHD_HTTP_METHOD_GET,
-                   MHD_HTTP_METHOD_POST,
-                   MHD_HTTP_METHOD_PUT,
-                   MHD_HTTP_METHOD_DELETE,
-                   MHD_HTTP_METHOD_OPTIONS);
+  GNUNET_asprintf (&allow_methods, "%s, %s, %s, %s, %s", MHD_HTTP_METHOD_GET,
+                   MHD_HTTP_METHOD_POST, MHD_HTTP_METHOD_PUT,
+                   MHD_HTTP_METHOD_DELETE, MHD_HTTP_METHOD_OPTIONS);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Identity Provider REST API initialized\n"));
+              _ ("Identity Provider REST API initialized\n"));
   return api;
 }