RECLAIM: less unneccessary crypto; syntax and build fixes

1 files changed, 143 insertions, 268 deletions

diff --git a/src/reclaim/gnunet-reclaim.c b/src/reclaim/gnunet-reclaim.c
index c36955a04..790813eec 100644
--- a/src/reclaim/gnunet-reclaim.c
+++ b/src/reclaim/gnunet-reclaim.c
@@ -23,14 +23,15 @@
  * @brief Identity Provider utility
  *
  */
-
 #include "platform.h"
+#include <inttypes.h>
+
 #include "gnunet_util_lib.h"
+
+#include "gnunet_identity_service.h"
 #include "gnunet_namestore_service.h"
 #include "gnunet_reclaim_service.h"
-#include "gnunet_identity_service.h"
 #include "gnunet_signatures.h"
-
 /**
  * return value
  */
@@ -44,37 +45,37 @@ static int list;
 /**
  * Relying party
  */
-static char* rp;
+static char *rp;
 
 /**
  * The attribute
  */
-static char* attr_name;
+static char *attr_name;
 
 /**
  * Attribute value
  */
-static char* attr_value;
+static char *attr_value;
 
 /**
  * Attributes to issue
  */
-static char* issue_attrs;
+static char *issue_attrs;
 
 /**
  * Ticket to consume
  */
-static char* consume_ticket;
+static char *consume_ticket;
 
 /**
  * Attribute type
  */
-static char* type_str;
+static char *type_str;
 
 /**
  * Ticket to revoke
  */
-static char* revoke_ticket;
+static char *revoke_ticket;
 
 /**
  * Ticket listing
@@ -84,7 +85,7 @@ static int list_tickets;
 /**
  * Ego name
  */
-static char* ego_name;
+static char *ego_name;
 
 /**
  * Identity handle
@@ -156,8 +157,7 @@ static struct GNUNET_SCHEDULER_Task *cleanup_task;
  */
 struct GNUNET_RECLAIM_ATTRIBUTE_Claim *claim;
 
-static void
-do_cleanup(void *cls)
+static void do_cleanup (void *cls)
 {
   cleanup_task = NULL;
   if (NULL != timeout)
@@ -178,196 +178,146 @@ do_cleanup(void *cls)
     GNUNET_free (attr_list);
 }
 
-static void
-ticket_issue_cb (void* cls,
-                 const struct GNUNET_RECLAIM_Ticket *ticket)
+static void ticket_issue_cb (void *cls,
+                             const struct GNUNET_RECLAIM_Ticket *ticket)
 {
-  char* ticket_str;
+  char *ticket_str;
   reclaim_op = NULL;
   if (NULL != ticket) {
-    ticket_str = GNUNET_STRINGS_data_to_string_alloc (ticket,
-                                                      sizeof (struct GNUNET_RECLAIM_Ticket));
-    printf("%s\n",
-           ticket_str);
+    ticket_str = GNUNET_STRINGS_data_to_string_alloc (
+        ticket, sizeof (struct GNUNET_RECLAIM_Ticket));
+    printf ("%s\n", ticket_str);
     GNUNET_free (ticket_str);
   }
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-store_attr_cont (void *cls,
-                 int32_t success,
-                 const char*emsg)
+static void store_attr_cont (void *cls, int32_t success, const char *emsg)
 {
   reclaim_op = NULL;
   if (GNUNET_SYSERR == success) {
-    fprintf (stderr,
-             "%s\n", emsg);
+    fprintf (stderr, "%s\n", emsg);
   }
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-process_attrs (void *cls,
-         const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-         const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
+static void process_attrs (void *cls,
+                           const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+                           const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 {
   char *value_str;
-  const char* attr_type;
+  const char *attr_type;
 
-  if (NULL == identity)
-  {
+  if (NULL == identity) {
     reclaim_op = NULL;
     cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
     return;
   }
-  if (NULL == attr)
-  {
+  if (NULL == attr) {
     ret = 1;
     return;
   }
-  value_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
-                                                        attr->data,
+  value_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type, attr->data,
                                                         attr->data_size);
   attr_type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
-  fprintf (stdout,
-           "%s: %s [%s,v%u,id=%lu]\n",
-           attr->name, value_str, attr_type, attr->version, attr->id);
+  fprintf (stdout, "%s: %s [%s,v%u,id=%" PRIu64 "]\n", attr->name, value_str,
+           attr_type, attr->version, attr->id);
 }
 
-static void
-ticket_iter_err (void *cls)
+static void ticket_iter_err (void *cls)
 {
   ticket_iterator = NULL;
-  fprintf (stderr,
-           "Failed to iterate over tickets\n");
+  fprintf (stderr, "Failed to iterate over tickets\n");
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-ticket_iter_fin (void *cls)
+static void ticket_iter_fin (void *cls)
 {
   ticket_iterator = NULL;
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-ticket_iter (void *cls,
-             const struct GNUNET_RECLAIM_Ticket *ticket)
+static void ticket_iter (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 {
-  fprintf (stdout,
-           "Found ticket\n");
+  fprintf (stdout, "Found ticket\n");
   GNUNET_RECLAIM_ticket_iteration_next (ticket_iterator);
 }
 
-static void
-iter_error (void *cls)
+static void iter_error (void *cls)
 {
   attr_iterator = NULL;
-  fprintf (stderr,
-           "Failed to iterate over attributes\n");
+  fprintf (stderr, "Failed to iterate over attributes\n");
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-timeout_task (void *cls)
+static void timeout_task (void *cls)
 {
   timeout = NULL;
   ret = 1;
-  fprintf (stderr,
-           "Timeout\n");
+  fprintf (stderr, "Timeout\n");
   if (NULL == cleanup_task)
     cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-process_rvk (void *cls, int success, const char* msg)
+static void process_rvk (void *cls, int success, const char *msg)
 {
   reclaim_op = NULL;
-  if (GNUNET_OK != success)
-  {
-    fprintf (stderr,
-             "Revocation failed.\n");
+  if (GNUNET_OK != success) {
+    fprintf (stderr, "Revocation failed.\n");
     ret = 1;
   }
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-iter_finished (void *cls)
+static void iter_finished (void *cls)
 {
   char *data;
   size_t data_size;
   int type;
 
   attr_iterator = NULL;
-  if (list)
-  {
+  if (list) {
     cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
     return;
   }
 
-  if (issue_attrs)
-  {
-    reclaim_op = GNUNET_RECLAIM_ticket_issue (reclaim_handle,
-                                              pkey,
-                                              &rp_key,
-                                              attr_list,
-                                              &ticket_issue_cb,
-                                              NULL);
+  if (issue_attrs) {
+    reclaim_op = GNUNET_RECLAIM_ticket_issue (
+        reclaim_handle, pkey, &rp_key, attr_list, &ticket_issue_cb, NULL);
     return;
   }
-  if (consume_ticket)
-  {
-    reclaim_op = GNUNET_RECLAIM_ticket_consume (reclaim_handle,
-                                                pkey,
-                                                &ticket,
-                                                &process_attrs,
-                                                NULL);
-    timeout = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10),
-                                            &timeout_task,
-                                            NULL);
+  if (consume_ticket) {
+    reclaim_op = GNUNET_RECLAIM_ticket_consume (reclaim_handle, pkey, &ticket,
+                                                &process_attrs, NULL);
+    timeout = GNUNET_SCHEDULER_add_delayed (
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10),
+        &timeout_task, NULL);
     return;
   }
-  if (revoke_ticket)
-  {
-    reclaim_op = GNUNET_RECLAIM_ticket_revoke (reclaim_handle,
-                                               pkey,
-                                               &ticket,
-                                               &process_rvk,
-                                               NULL);
+  if (revoke_ticket) {
+    reclaim_op = GNUNET_RECLAIM_ticket_revoke (reclaim_handle, pkey, &ticket,
+                                               &process_rvk, NULL);
     return;
   }
-  if (attr_name)
-  {
+  if (attr_name) {
     if (NULL == type_str)
       type = GNUNET_RECLAIM_ATTRIBUTE_TYPE_STRING;
     else
       type = GNUNET_RECLAIM_ATTRIBUTE_typename_to_number (type_str);
 
-    GNUNET_assert (GNUNET_SYSERR != GNUNET_RECLAIM_ATTRIBUTE_string_to_value (type,
-                                                                              attr_value,
-                                                                              (void**)&data,
-                                                                              &data_size));
-    if (NULL != claim)
-    {
+    GNUNET_assert (GNUNET_SYSERR !=
+                   GNUNET_RECLAIM_ATTRIBUTE_string_to_value (
+                       type, attr_value, (void **)&data, &data_size));
+    if (NULL != claim) {
       claim->type = type;
       claim->data = data;
       claim->data_size = data_size;
+    } else {
+      claim =
+          GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr_name, type, data, data_size);
     }
-    else
-    {
-      claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr_name,
-                                                  type,
-                                                  data,
-                                                  data_size);
-    }
-    reclaim_op = GNUNET_RECLAIM_attribute_store (reclaim_handle,
-                                                 pkey,
-                                                 claim,
-                                                 &exp_interval,
-                                                 &store_attr_cont,
-                                                 NULL);
+    reclaim_op = GNUNET_RECLAIM_attribute_store (
+        reclaim_handle, pkey, claim, &exp_interval, &store_attr_cont, NULL);
     GNUNET_free (data);
     GNUNET_free (claim);
     return;
@@ -375,28 +325,21 @@ iter_finished (void *cls)
   cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
 }
 
-static void
-iter_cb (void *cls,
-         const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
-         const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
+static void iter_cb (void *cls,
+                     const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+                     const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 {
   struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *le;
   char *attrs_tmp;
   char *attr_str;
   const char *attr_type;
 
-  if ((NULL != attr_name) && (NULL != claim))
-  {
-    if (0 == strcasecmp (attr_name, attr->name))
-    {
-      claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr->name,
-                                                            attr->type,
-                                                            attr->data,
-                                                            attr->data_size);
+  if ((NULL != attr_name) && (NULL != claim)) {
+    if (0 == strcasecmp (attr_name, attr->name)) {
+      claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr->name, attr->type,
+                                                  attr->data, attr->data_size);
     }
-  }
-  else if (issue_attrs)
-  {
+  } else if (issue_attrs) {
     attrs_tmp = GNUNET_strdup (issue_attrs);
     attr_str = strtok (attrs_tmp, ",");
     while (NULL != attr_str) {
@@ -405,92 +348,62 @@ iter_cb (void *cls,
         continue;
       }
       le = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry);
-      le->claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (attr->name,
-                                                      attr->type,
-                                                      attr->data,
-                                                      attr->data_size);
+      le->claim = GNUNET_RECLAIM_ATTRIBUTE_claim_new (
+          attr->name, attr->type, attr->data, attr->data_size);
       le->claim->version = attr->version;
       le->claim->id = attr->id;
-      GNUNET_CONTAINER_DLL_insert (attr_list->list_head,
-                                   attr_list->list_tail,
+      GNUNET_CONTAINER_DLL_insert (attr_list->list_head, attr_list->list_tail,
                                    le);
       break;
     }
     GNUNET_free (attrs_tmp);
-  }
-  else if (list)
-  {
-    attr_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
-                                                         attr->data,
+  } else if (list) {
+    attr_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type, attr->data,
                                                          attr->data_size);
     attr_type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
-    fprintf (stdout,
-             "%s: %s [%s,v%u,id=%lu]\n",
-             attr->name, attr_str, attr_type, attr->version, attr->id);
+    fprintf (stdout, "%s: %s [%s,v%u,id=%" PRIu64 "]\n", attr->name, attr_str,
+             attr_type, attr->version, attr->id);
   }
   GNUNET_RECLAIM_get_attributes_next (attr_iterator);
 }
 
-static void
-start_process ()
+static void start_process ()
 {
-  if (NULL == pkey)
-  {
-    fprintf (stderr,
-             "Ego %s not found\n", ego_name);
+  if (NULL == pkey) {
+    fprintf (stderr, "Ego %s not found\n", ego_name);
     cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup, NULL);
     return;
   }
 
-  if (list_tickets)
-  {
-    ticket_iterator = GNUNET_RECLAIM_ticket_iteration_start (reclaim_handle,
-                                                             pkey,
-                                                             &ticket_iter_err,
-                                                             NULL,
-                                                             &ticket_iter,
-                                                             NULL,
-                                                             &ticket_iter_fin,
-                                                             NULL);
+  if (list_tickets) {
+    ticket_iterator = GNUNET_RECLAIM_ticket_iteration_start (
+        reclaim_handle, pkey, &ticket_iter_err, NULL, &ticket_iter, NULL,
+        &ticket_iter_fin, NULL);
     return;
   }
 
   if (NULL != rp)
-    GNUNET_CRYPTO_ecdsa_public_key_from_string (rp,
-                                                strlen (rp),
-                                                &rp_key);
+    GNUNET_CRYPTO_ecdsa_public_key_from_string (rp, strlen (rp), &rp_key);
   if (NULL != consume_ticket)
-    GNUNET_STRINGS_string_to_data (consume_ticket,
-                                   strlen (consume_ticket),
+    GNUNET_STRINGS_string_to_data (consume_ticket, strlen (consume_ticket),
                                    &ticket,
                                    sizeof (struct GNUNET_RECLAIM_Ticket));
   if (NULL != revoke_ticket)
-    GNUNET_STRINGS_string_to_data (revoke_ticket,
-                                   strlen (revoke_ticket),
+    GNUNET_STRINGS_string_to_data (revoke_ticket, strlen (revoke_ticket),
                                    &ticket,
                                    sizeof (struct GNUNET_RECLAIM_Ticket));
 
   attr_list = GNUNET_new (struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList);
   claim = NULL;
-  attr_iterator = GNUNET_RECLAIM_get_attributes_start (reclaim_handle,
-                                                       pkey,
-                                                       &iter_error,
-                                                       NULL,
-                                                       &iter_cb,
-                                                       NULL,
-                                                       &iter_finished,
-                                                       NULL);
-
-
+  attr_iterator = GNUNET_RECLAIM_get_attributes_start (
+      reclaim_handle, pkey, &iter_error, NULL, &iter_cb, NULL, &iter_finished,
+      NULL);
 }
 
 static int init = GNUNET_YES;
 
-static void
-ego_cb (void *cls,
-        struct GNUNET_IDENTITY_Ego *ego,
-        void **ctx,
-        const char *name)
+static void ego_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
+                    const char *name)
 {
   if (NULL == name) {
     if (GNUNET_YES == init) {
@@ -505,113 +418,75 @@ ego_cb (void *cls,
 }
 
 
-static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+static void run (void *cls, char *const *args, const char *cfgfile,
+                 const struct GNUNET_CONFIGURATION_Handle *c)
 {
   ret = 0;
-  if (NULL == ego_name)
-  {
+  if (NULL == ego_name) {
     ret = 1;
-    fprintf (stderr,
-             _("Ego is required\n"));
+    fprintf (stderr, _ ("Ego is required\n"));
     return;
   }
 
-  if ( (NULL == attr_value) && (NULL != attr_name) )
-  {
+  if ((NULL == attr_value) && (NULL != attr_name)) {
     ret = 1;
-    fprintf (stderr,
-             _("Attribute value missing!\n"));
+    fprintf (stderr, _ ("Attribute value missing!\n"));
     return;
   }
 
-  if ( (NULL == rp) && (NULL != issue_attrs) )
-  {
+  if ((NULL == rp) && (NULL != issue_attrs)) {
     ret = 1;
-    fprintf (stderr,
-             _("Requesting party key is required!\n"));
+    fprintf (stderr, _ ("Requesting party key is required!\n"));
     return;
   }
 
   reclaim_handle = GNUNET_RECLAIM_connect (c);
-  //Get Ego
-  identity_handle = GNUNET_IDENTITY_connect (c,
-                                             &ego_cb,
-                                             NULL);
-
-
+  // Get Ego
+  identity_handle = GNUNET_IDENTITY_connect (c, &ego_cb, NULL);
 }
 
 
-int
-main(int argc, char *const argv[])
+int main (int argc, char *const argv[])
 {
   exp_interval = GNUNET_TIME_UNIT_HOURS;
   struct GNUNET_GETOPT_CommandLineOption options[] = {
 
-    GNUNET_GETOPT_option_string ('a',
-                                 "add",
-                                 "NAME",
-                                 gettext_noop ("Add an attribute NAME"),
-                                 &attr_name),
-
-    GNUNET_GETOPT_option_string ('V',
-                                 "value",
-                                 "VALUE",
-                                 gettext_noop ("The attribute VALUE"),
-                                 &attr_value),
-    GNUNET_GETOPT_option_string ('e',
-                                 "ego",
-                                 "EGO",
-                                 gettext_noop ("The EGO to use"),
-                                 &ego_name),
-    GNUNET_GETOPT_option_string ('r',
-                                 "rp",
-                                 "RP",
-                                 gettext_noop ("Specify the relying party for issue"),
-                                 &rp),
-    GNUNET_GETOPT_option_flag ('D',
-                               "dump",
-                               gettext_noop ("List attributes for EGO"),
-                               &list),
-    GNUNET_GETOPT_option_string ('i',
-                                 "issue",
-                                 "A1,A2,...",
-                                 gettext_noop ("Issue a ticket for a set of attributes separated by comma"),
-                                 &issue_attrs),
-    GNUNET_GETOPT_option_string ('C',
-                                 "consume",
-                                 "TICKET",
-                                 gettext_noop ("Consume a ticket"),
-                                 &consume_ticket),
-    GNUNET_GETOPT_option_string ('R',
-                                 "revoke",
-                                 "TICKET",
-                                 gettext_noop ("Revoke a ticket"),
-                                 &revoke_ticket),
-    GNUNET_GETOPT_option_string ('t',
-                                 "type",
-                                 "TYPE",
-                                 gettext_noop ("Type of attribute"),
-                                 &type_str),
-    GNUNET_GETOPT_option_flag ('T',
-                               "tickets",
-                               gettext_noop ("List tickets of ego"),
-                               &list_tickets),
-    GNUNET_GETOPT_option_relative_time ('E',
-                                        "expiration",
-                                        "INTERVAL",
-                                        gettext_noop ("Expiration interval of the attribute"),
-                                        &exp_interval),
-
-    GNUNET_GETOPT_OPTION_END
-  };
-  if (GNUNET_OK != GNUNET_PROGRAM_run (argc, argv, "ct",
-                                       "ct", options,
-                                       &run, NULL))
+      GNUNET_GETOPT_option_string ('a', "add", "NAME",
+                                   gettext_noop ("Add an attribute NAME"),
+                                   &attr_name),
+
+      GNUNET_GETOPT_option_string ('V', "value", "VALUE",
+                                   gettext_noop ("The attribute VALUE"),
+                                   &attr_value),
+      GNUNET_GETOPT_option_string ('e', "ego", "EGO",
+                                   gettext_noop ("The EGO to use"), &ego_name),
+      GNUNET_GETOPT_option_string (
+          'r', "rp", "RP", gettext_noop ("Specify the relying party for issue"),
+          &rp),
+      GNUNET_GETOPT_option_flag (
+          'D', "dump", gettext_noop ("List attributes for EGO"), &list),
+      GNUNET_GETOPT_option_string (
+          'i', "issue", "A1,A2,...",
+          gettext_noop (
+              "Issue a ticket for a set of attributes separated by comma"),
+          &issue_attrs),
+      GNUNET_GETOPT_option_string ('C', "consume", "TICKET",
+                                   gettext_noop ("Consume a ticket"),
+                                   &consume_ticket),
+      GNUNET_GETOPT_option_string ('R', "revoke", "TICKET",
+                                   gettext_noop ("Revoke a ticket"),
+                                   &revoke_ticket),
+      GNUNET_GETOPT_option_string (
+          't', "type", "TYPE", gettext_noop ("Type of attribute"), &type_str),
+      GNUNET_GETOPT_option_flag (
+          'T', "tickets", gettext_noop ("List tickets of ego"), &list_tickets),
+      GNUNET_GETOPT_option_relative_time (
+          'E', "expiration", "INTERVAL",
+          gettext_noop ("Expiration interval of the attribute"), &exp_interval),
+
+      GNUNET_GETOPT_OPTION_END};
+  if (GNUNET_OK !=
+      GNUNET_PROGRAM_run (argc, argv, "ct", "ct", options, &run, NULL))
     return 1;
   else
     return ret;