clang-format

1 files changed, 196 insertions, 97 deletions

diff --git a/src/reclaim/plugin_rest_reclaim.c b/src/reclaim/plugin_rest_reclaim.c
index 9e57f4f46..1efd1f9ea 100644
--- a/src/reclaim/plugin_rest_reclaim.c
+++ b/src/reclaim/plugin_rest_reclaim.c
@@ -264,8 +264,10 @@ 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;) {
+  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);
@@ -273,14 +275,16 @@ cleanup_handle (struct RequestHandle *handle)
     }
     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) {
+  if (NULL != handle->attr_it)
+  {
     GNUNET_free (handle->attr_it);
   }
   GNUNET_free (handle);
@@ -306,7 +310,8 @@ do_error (void *cls)
   char *json_error;
 
   GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
-  if (0 == handle->response_code) {
+  if (0 == handle->response_code)
+  {
     handle->response_code = MHD_HTTP_BAD_REQUEST;
   }
   resp = GNUNET_REST_create_response (json_error);
@@ -347,7 +352,8 @@ finished_cont (void *cls, int32_t success, const char *emsg)
   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;
   }
@@ -405,13 +411,17 @@ ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
   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));
+  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));
+  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);
@@ -432,16 +442,19 @@ ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
  */
 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;
   struct EgoEntry *ego_entry;
   char *identity;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting tickets for %s.\n",
+  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;
@@ -454,7 +467,8 @@ list_tickets_cont (struct GNUNET_REST_RequestHandle *con_handle,
       break;
   handle->resp_object = json_array ();
 
-  if (NULL == ego_entry) {
+  if (NULL == ego_entry)
+  {
     // Done
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
     GNUNET_SCHEDULER_add_now (&return_response, handle);
@@ -462,15 +476,22 @@ list_tickets_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->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;
@@ -481,12 +502,14 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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 ()};
+  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",
+  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;
@@ -498,26 +521,31 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
     if (0 == strcmp (identity, ego_entry->identifier))
       break;
 
-  if (NULL == ego_entry) {
+  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);
   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",
+  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;
@@ -530,8 +558,12 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
       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);
 }
 
@@ -541,7 +573,8 @@ add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
  *
  */
 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;
@@ -550,14 +583,16 @@ attr_collect (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
   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);
 
-  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 ();
@@ -583,16 +618,19 @@ attr_collect (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
  */
 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;
   struct EgoEntry *ego_entry;
   char *identity;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting attributes for %s.\n",
+  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;
@@ -606,7 +644,8 @@ list_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   handle->resp_object = json_array ();
 
 
-  if (NULL == ego_entry) {
+  if (NULL == ego_entry)
+  {
     // Done
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
     GNUNET_SCHEDULER_add_now (&return_response, handle);
@@ -614,9 +653,14 @@ list_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);
-  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);
 }
 
 
@@ -627,7 +671,8 @@ delete_finished_cb (void *cls, int32_t success, const char *emsg)
   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;
   }
@@ -645,7 +690,8 @@ delete_finished_cb (void *cls, int32_t success, const char *emsg)
  */
 static void
 delete_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;
@@ -656,7 +702,8 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   char *id;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting attributes.\n");
-  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;
@@ -665,7 +712,8 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
     strdup (handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1);
   identity = strtok (identity_id_str, "/");
   id = strtok (NULL, "/");
-  if ((NULL == identity) || (NULL == id)) {
+  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);
@@ -677,7 +725,8 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
     if (0 == strcmp (identity, ego_entry->identifier))
       break;
   handle->resp_object = json_array ();
-  if (NULL == ego_entry) {
+  if (NULL == ego_entry)
+  {
     // Done
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
     GNUNET_free (identity_id_str);
@@ -689,15 +738,19 @@ delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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);
+  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)
+                    const char *url,
+                    void *cls)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
   struct RequestHandle *handle = cls;
@@ -707,19 +760,22 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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 ()};
+  struct GNUNET_JSON_Specification tktspec[] =
+    {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 (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);
@@ -727,21 +783,26 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
     return;
   }
   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;
   }
 
   for (ego_entry = handle->ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next) {
+       ego_entry = ego_entry->next)
+  {
     GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
-    if (0 == memcmp (&ticket->identity, &tmp_pk,
+    if (0 == memcmp (&ticket->identity,
+                     &tmp_pk,
                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
       break;
   }
-  if (NULL == ego_entry) {
+  if (NULL == ego_entry)
+  {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
     GNUNET_JSON_parse_free (tktspec);
     return;
@@ -749,29 +810,37 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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,
+  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",
+  if (NULL == val_str)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to parse value for: %s\n",
                 attr->name);
     return;
   }
@@ -783,7 +852,8 @@ consume_cont (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
 
 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;
@@ -793,25 +863,30 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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 ()};
+  struct GNUNET_JSON_Specification tktspec[] =
+    {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) {
+  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);
@@ -819,13 +894,16 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
     return;
   }
   for (ego_entry = handle->ego_head; NULL != ego_entry;
-       ego_entry = ego_entry->next) {
+       ego_entry = ego_entry->next)
+  {
     GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
-    if (0 == memcmp (&ticket->audience, &tmp_pk,
+    if (0 == memcmp (&ticket->audience,
+                     &tmp_pk,
                      sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
       break;
   }
-  if (NULL == ego_entry) {
+  if (NULL == ego_entry)
+  {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
     GNUNET_JSON_parse_free (tktspec);
     return;
@@ -833,8 +911,11 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
   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);
 }
 
@@ -847,7 +928,8 @@ 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;
@@ -870,24 +952,31 @@ static void
 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,
+  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,
+     {MHD_HTTP_METHOD_POST,
+      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
       &add_attribute_cont},
-    {MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+     {MHD_HTTP_METHOD_DELETE,
+      GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
       &delete_attribute_cont},
-    {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_TICKETS,
+     {MHD_HTTP_METHOD_GET,
+      GNUNET_REST_API_NS_IDENTITY_TICKETS,
       &list_tickets_cont},
-    {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_REVOKE,
+     {MHD_HTTP_METHOD_POST,
+      GNUNET_REST_API_NS_IDENTITY_REVOKE,
       &revoke_ticket_cont},
-    {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_CONSUME,
+     {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};
+     {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)) {
+  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);
   }
@@ -927,32 +1016,38 @@ 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;
   }
-  if (ID_REST_STATE_INIT == handle->state) {
+  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,
+    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)
+                               GNUNET_REST_ResultProcessor proc,
+                               void *proc_cls)
 {
   struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
   handle->response_code = 0;
@@ -993,9 +1088,13 @@ libgnunet_plugin_rest_reclaim_init (void *cls)
   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"));