1 files changed, 471 insertions, 470 deletions

diff --git a/src/reclaim/plugin_rest_reclaim.c b/src/reclaim/plugin_rest_reclaim.c
index 3f2577802..176f46ffc 100644
--- a/src/reclaim/plugin_rest_reclaim.c
+++ b/src/reclaim/plugin_rest_reclaim.c
@@ -16,7 +16,7 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    SPDX-License-Identifier: AGPL3.0-or-later
-   */
+ */
 /**
  * @author Martin Schanzenbach
  * @author Philippe Buschmann
@@ -86,16 +86,14 @@ static char *allow_methods;
 /**
  * @brief struct returned by the initialization function of the plugin
  */
-struct Plugin
-{
+struct Plugin {
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 };
 
 /**
  * The ego list
  */
-struct EgoEntry
-{
+struct EgoEntry {
   /**
    * DLL
    */
@@ -123,8 +121,7 @@ struct EgoEntry
 };
 
 
-struct RequestHandle
-{
+struct RequestHandle {
   /**
    * Ego list
    */
@@ -241,55 +238,56 @@ struct RequestHandle
  * @param handle Handle to clean up
  */
 static void
-cleanup_handle (struct RequestHandle *handle)
+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;
-  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);
+    json_decref(handle->resp_object);
   if (NULL != handle->timeout_task)
-    GNUNET_SCHEDULER_cancel (handle->timeout_task);
+    GNUNET_SCHEDULER_cancel(handle->timeout_task);
   if (NULL != handle->identity_handle)
-    GNUNET_IDENTITY_disconnect (handle->identity_handle);
+    GNUNET_IDENTITY_disconnect(handle->identity_handle);
   if (NULL != handle->attr_it)
-    GNUNET_RECLAIM_get_attributes_stop (handle->attr_it);
+    GNUNET_RECLAIM_get_attributes_stop(handle->attr_it);
   if (NULL != handle->ticket_it)
-    GNUNET_RECLAIM_ticket_iteration_stop (handle->ticket_it);
+    GNUNET_RECLAIM_ticket_iteration_stop(handle->ticket_it);
   if (NULL != handle->idp)
-    GNUNET_RECLAIM_disconnect (handle->idp);
+    GNUNET_RECLAIM_disconnect(handle->idp);
   if (NULL != handle->url)
-    GNUNET_free (handle->url);
+    GNUNET_free(handle->url);
   if (NULL != handle->emsg)
-    GNUNET_free (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);
+      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(handle->attr_list);
     }
-    GNUNET_free (handle->attr_list);
-  }
   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);
-  }
-  GNUNET_free (handle);
+    {
+      ego_tmp = ego_entry;
+      ego_entry = ego_entry->next;
+      GNUNET_free(ego_tmp->identifier);
+      GNUNET_free(ego_tmp->keystring);
+      GNUNET_free(ego_tmp);
+    }
+  GNUNET_free(handle);
 }
 
 static void
-cleanup_handle_delayed (void *cls)
+cleanup_handle_delayed(void *cls)
 {
-  cleanup_handle (cls);
+  cleanup_handle(cls);
 }
 
 
@@ -299,22 +297,22 @@ cleanup_handle_delayed (void *cls)
  * @param cls the `struct RequestHandle`
  */
 static void
-do_error (void *cls)
+do_error(void *cls)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
   char *json_error;
 
-  GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
+  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);
-  MHD_add_response_header (resp, "Content-Type", "application/json");
-  handle->proc (handle->proc_cls, resp, handle->response_code);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle_delayed, handle);
-  GNUNET_free (json_error);
+    {
+      handle->response_code = MHD_HTTP_BAD_REQUEST;
+    }
+  resp = GNUNET_REST_create_response(json_error);
+  MHD_add_response_header(resp, "Content-Type", "application/json");
+  handle->proc(handle->proc_cls, resp, handle->response_code);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle_delayed, handle);
+  GNUNET_free(json_error);
 }
 
 
@@ -324,37 +322,37 @@ do_error (void *cls)
  * @param cls the `struct RequestHandle`
  */
 static void
-do_timeout (void *cls)
+do_timeout(void *cls)
 {
   struct RequestHandle *handle = cls;
 
   handle->timeout_task = NULL;
-  do_error (handle);
+  do_error(handle);
 }
 
 
 static void
-collect_error_cb (void *cls)
+collect_error_cb(void *cls)
 {
   struct RequestHandle *handle = cls;
 
-  do_error (handle);
+  do_error(handle);
 }
 
 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);
+  resp = GNUNET_REST_create_response(emsg);
   if (GNUNET_OK != success)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle_delayed, handle);
+    {
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle_delayed, handle);
 }
 
 
@@ -364,28 +362,29 @@ finished_cont (void *cls, int32_t success, const char *emsg)
  * @param cls the request handle
  */
 static void
-return_response (void *cls)
+return_response(void *cls)
 {
   char *result_str;
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
 
-  result_str = json_dumps (handle->resp_object, 0);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
-  resp = GNUNET_REST_create_response (result_str);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free (result_str);
-  cleanup_handle (handle);
+  result_str = json_dumps(handle->resp_object, 0);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+  resp = GNUNET_REST_create_response(result_str);
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_free(result_str);
+  cleanup_handle(handle);
 }
 
 static void
-collect_finished_cb (void *cls)
+collect_finished_cb(void *cls)
 {
   struct RequestHandle *handle = cls;
+
   // Done
   handle->attr_it = NULL;
   handle->ticket_it = NULL;
-  GNUNET_SCHEDULER_add_now (&return_response, handle);
+  GNUNET_SCHEDULER_add_now(&return_response, handle);
 }
 
 
@@ -394,38 +393,38 @@ 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;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding ticket\n");
-  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);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding ticket\n");
+  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);
 
   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);
-  GNUNET_free (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);
+  GNUNET_free(tmp);
   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);
-  GNUNET_free (tmp);
-  tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t));
-  value = json_string (tmp);
-  json_object_set_new (json_resource, "rnd", value);
-  GNUNET_free (tmp);
-  GNUNET_RECLAIM_ticket_iteration_next (handle->ticket_it);
+    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);
+  GNUNET_free(tmp);
+  tmp = GNUNET_STRINGS_data_to_string_alloc(&ticket->rnd, sizeof(uint64_t));
+  value = json_string(tmp);
+  json_object_set_new(json_resource, "rnd", value);
+  GNUNET_free(tmp);
+  GNUNET_RECLAIM_ticket_iteration_next(handle->ticket_it);
 }
 
 
@@ -437,57 +436,57 @@ ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
  * @param cls the RequestHandle
  */
 static void
-list_tickets_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                   const char *url,
-                   void *cls)
+list_tickets_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 tickets for %s.\n",
-              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;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Getting tickets for %s.\n",
+             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;
        ego_entry = ego_entry->next)
-    if (0 == strcmp (identity, ego_entry->identifier))
+    if (0 == strcmp(identity, ego_entry->identifier))
       break;
-  handle->resp_object = json_array ();
+  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);
+    {
+      // 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);
+    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)
+add_attribute_cont(struct GNUNET_REST_RequestHandle *con_handle,
+                   const char *url,
+                   void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   const char *identity;
@@ -499,68 +498,68 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   json_t *data_json;
   json_error_t err;
   struct GNUNET_JSON_Specification attrspec[] =
-    {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))
-  {
-    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;
+  { 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))
+    {
+      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;
        ego_entry = ego_entry->next)
-    if (0 == strcmp (identity, ego_entry->identifier))
+    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);
+    {
+      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;
-  }
+    {
+      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);
+  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 attribute from %s\n",
-                term_data);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      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
    */
   if (0 == attribute->id)
     attribute->id =
-      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
-  handle->idp = GNUNET_RECLAIM_connect (cfg);
+      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);
-  GNUNET_JSON_parse_free (attrspec);
+  handle->idp_op = GNUNET_RECLAIM_attribute_store(handle->idp,
+                                                  identity_priv,
+                                                  attribute,
+                                                  &exp,
+                                                  &finished_cont,
+                                                  handle);
+  GNUNET_JSON_parse_free(attrspec);
 }
 
 
@@ -569,9 +568,9 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
  *
  */
 static void
-attr_collect (void *cls,
-              const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-              const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
+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;
@@ -580,28 +579,28 @@ attr_collect (void *cls,
   char *id_str;
 
   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);
-
-  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));
-  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 (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_RECLAIM_get_attributes_next (handle->attr_it);
+    {
+      GNUNET_RECLAIM_get_attributes_next(handle->attr_it);
+      return;
+    }
+
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
+
+  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));
+  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(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_RECLAIM_get_attributes_next(handle->attr_it);
 }
 
 
@@ -613,67 +612,67 @@ attr_collect (void *cls,
  * @param cls the RequestHandle
  */
 static void
-list_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                     const char *url,
-                     void *cls)
+list_attribute_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 attributes for %s.\n",
-              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;
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Getting attributes for %s.\n",
+             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;
        ego_entry = ego_entry->next)
-    if (0 == strcmp (identity, ego_entry->identifier))
+    if (0 == strcmp(identity, ego_entry->identifier))
       break;
-  handle->resp_object = json_array ();
+  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,
-                                                         &attr_collect,
-                                                         handle,
-                                                         &collect_finished_cb,
-                                                         handle);
+    {
+      // 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);
 }
 
 
 static void
-delete_finished_cb (void *cls, int32_t success, const char *emsg)
+delete_finished_cb(void *cls, int32_t success, const char *emsg)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
 
-  resp = GNUNET_REST_create_response (emsg);
+  resp = GNUNET_REST_create_response(emsg);
   if (GNUNET_OK != success)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_SCHEDULER_add_now (&cleanup_handle_delayed, handle);
+    {
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      return;
+    }
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  GNUNET_SCHEDULER_add_now(&cleanup_handle_delayed, handle);
 }
 
 
@@ -685,9 +684,9 @@ delete_finished_cb (void *cls, int32_t success, const char *emsg)
  * @param cls the RequestHandle
  */
 static void
-delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                       const char *url,
-                       void *cls)
+delete_attribute_cont(struct GNUNET_REST_RequestHandle *con_handle,
+                      const char *url,
+                      void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
   struct RequestHandle *handle = cls;
@@ -697,56 +696,56 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   char *identity;
   char *id;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting attributes.\n");
-  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;
-  }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Deleting attributes.\n");
+  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_id_str =
-    strdup (handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1);
-  identity = strtok (identity_id_str, "/");
-  id = strtok (NULL, "/");
+    strdup(handle->url + strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1);
+  identity = strtok(identity_id_str, "/");
+  id = strtok(NULL, "/");
   if ((NULL == identity) || (NULL == id))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
-    GNUNET_free (identity_id_str);
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
+      GNUNET_free(identity_id_str);
+      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))
+    if (0 == strcmp(identity, ego_entry->identifier))
       break;
-  handle->resp_object = json_array ();
+  handle->resp_object = json_array();
   if (NULL == ego_entry)
-  {
-    // Done
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
-    GNUNET_free (identity_id_str);
-    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);
-  memset (&attr, 0, sizeof (struct GNUNET_RECLAIM_ATTRIBUTE_Claim));
-  GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof (uint64_t));
+    {
+      // Done
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
+      GNUNET_free(identity_id_str);
+      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);
+  memset(&attr, 0, sizeof(struct GNUNET_RECLAIM_ATTRIBUTE_Claim));
+  GNUNET_STRINGS_string_to_data(id, strlen(id), &attr.id, sizeof(uint64_t));
   attr.name = "";
-  handle->idp_op = GNUNET_RECLAIM_attribute_delete (handle->idp,
-                                                    priv_key,
-                                                    &attr,
-                                                    &delete_finished_cb,
-                                                    handle);
-  GNUNET_free (identity_id_str);
+  handle->idp_op = GNUNET_RECLAIM_attribute_delete(handle->idp,
+                                                   priv_key,
+                                                   &attr,
+                                                   &delete_finished_cb,
+                                                   handle);
+  GNUNET_free(identity_id_str);
 }
 
 
 static void
-revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                    const char *url,
-                    void *cls)
+revoke_ticket_cont(struct GNUNET_REST_RequestHandle *con_handle,
+                   const char *url,
+                   void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   struct RequestHandle *handle = cls;
@@ -757,101 +756,101 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      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_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) ||
-      (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);
-    if (NULL != data_json)
-      json_decref (data_json);
-    return;
-  }
-  json_decref (data_json);
+      (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);
+      if (NULL != data_json)
+        json_decref(data_json);
+      return;
+    }
+  json_decref(data_json);
   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;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to parse ticket from %s\n",
+                 term_data);
+      GNUNET_SCHEDULER_add_now(&do_error, 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,
-                     sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
-      break;
-  }
+    {
+      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");
-    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);
-  GNUNET_JSON_parse_free (tktspec);
+    {
+      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);
+  GNUNET_JSON_parse_free(tktspec);
 }
 
 static void
-consume_cont (void *cls,
-              const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-              const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
+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)
-  {
-    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,
-                                                      attr->data_size);
+    {
+      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,
+                                                     attr->data_size);
   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);
-  json_decref (value);
-  GNUNET_free (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);
+  json_decref(value);
+  GNUNET_free(val_str);
 }
 
 static void
-consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
-                     const char *url,
-                     void *cls)
+consume_ticket_cont(struct GNUNET_REST_RequestHandle *con_handle,
+                    const char *url,
+                    void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   struct RequestHandle *handle = cls;
@@ -862,59 +861,59 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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)
-  {
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    return;
-  }
+    {
+      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_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)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "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))
-  {
-    handle->emsg = GNUNET_strdup ("Not a ticket!\n");
-    GNUNET_SCHEDULER_add_now (&do_error, handle);
-    GNUNET_JSON_parse_free (tktspec);
-    json_decref (data_json);
-    return;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "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))
+    {
+      handle->emsg = GNUNET_strdup("Not a ticket!\n");
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+      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,
-                     sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
-      break;
-  }
+    {
+      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");
-    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);
-  GNUNET_JSON_parse_free (tktspec);
+    {
+      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);
+  GNUNET_JSON_parse_free(tktspec);
 }
 
 
@@ -926,18 +925,18 @@ 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,
-              void *cls)
+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
-  resp = GNUNET_REST_create_response (NULL);
-  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
-  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  cleanup_handle (handle);
+  resp = GNUNET_REST_create_response(NULL);
+  MHD_add_response_header(resp, "Access-Control-Allow-Methods", allow_methods);
+  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
+  cleanup_handle(handle);
   return;
 }
 
@@ -947,37 +946,37 @@ options_cont (struct GNUNET_REST_RequestHandle *con_handle,
  * @param handle the request handle
  */
 static void
-init_cont (struct RequestHandle *handle)
+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,
+  { { MHD_HTTP_METHOD_GET,
       GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
-      &add_attribute_cont},
-     {MHD_HTTP_METHOD_DELETE,
-      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
-      &delete_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};
+      &list_attribute_cont },
+    { MHD_HTTP_METHOD_POST,
+        GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+        &add_attribute_cont },
+    { MHD_HTTP_METHOD_DELETE,
+        GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+        &delete_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);
-  }
+      GNUNET_REST_handle_request(handle->rest_handle, handlers, &err, handle))
+    {
+      handle->response_code = err.error_code;
+      GNUNET_SCHEDULER_add_now(&do_error, handle);
+    }
 }
 
 /**
@@ -1014,40 +1013,41 @@ init_cont (struct RequestHandle *handle)
  *                   must thus no longer be used
  */
 static void
-list_ego (void *cls,
-          struct GNUNET_IDENTITY_Ego *ego,
-          void **ctx,
-          const char *identifier)
+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))
-  {
-    handle->state = ID_REST_STATE_POST_INIT;
-    init_cont (handle);
-    return;
-  }
+    {
+      handle->state = ID_REST_STATE_POST_INIT;
+      init_cont(handle);
+      return;
+    }
   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->ego = ego;
-    ego_entry->identifier = GNUNET_strdup (identifier);
-    GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head,
-                                      handle->ego_tail,
-                                      ego_entry);
-  }
+    {
+      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->ego = ego;
+      ego_entry->identifier = GNUNET_strdup(identifier);
+      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);
+  struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
+
   handle->response_code = 0;
   handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
   handle->proc_cls = proc_cls;
@@ -1055,14 +1055,14 @@ rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
   handle->state = ID_REST_STATE_INIT;
   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);
+  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);
   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");
 }
 
 /**
@@ -1072,7 +1072,7 @@ rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
  * @return NULL on error, otherwise the plugin context
  */
 void *
-libgnunet_plugin_rest_reclaim_init (void *cls)
+libgnunet_plugin_rest_reclaim_init(void *cls)
 {
   static struct Plugin plugin;
   struct GNUNET_REST_Plugin *api;
@@ -1080,22 +1080,22 @@ libgnunet_plugin_rest_reclaim_init (void *cls)
   cfg = cls;
   if (NULL != plugin.cfg)
     return NULL; /* can only initialize once! */
-  memset (&plugin, 0, sizeof (struct Plugin));
+  memset(&plugin, 0, sizeof(struct Plugin));
   plugin.cfg = cfg;
-  api = GNUNET_new (struct GNUNET_REST_Plugin);
+  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_log (GNUNET_ERROR_TYPE_DEBUG,
-              _ ("Identity Provider REST API initialized\n"));
+  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"));
   return api;
 }
 
@@ -1107,16 +1107,17 @@ libgnunet_plugin_rest_reclaim_init (void *cls)
  * @return always NULL
  */
 void *
-libgnunet_plugin_rest_reclaim_done (void *cls)
+libgnunet_plugin_rest_reclaim_done(void *cls)
 {
   struct GNUNET_REST_Plugin *api = cls;
   struct Plugin *plugin = api->cls;
+
   plugin->cfg = NULL;
 
-  GNUNET_free_non_null (allow_methods);
-  GNUNET_free (api);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Identity Provider REST plugin is finished\n");
+  GNUNET_free_non_null(allow_methods);
+  GNUNET_free(api);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Identity Provider REST plugin is finished\n");
   return NULL;
 }