global reindent, now with uncrustify hook enabled

1 files changed, 246 insertions, 245 deletions

diff --git a/src/revocation/gnunet-revocation.c b/src/revocation/gnunet-revocation.c
index da93e6903..652c1e62d 100644
--- a/src/revocation/gnunet-revocation.c
+++ b/src/revocation/gnunet-revocation.c
@@ -91,23 +91,23 @@ static struct GNUNET_SCHEDULER_Task *pow_task;
  * @param cls closure
  */
 static void
-do_shutdown(void *cls)
+do_shutdown (void *cls)
 {
   if (NULL != el)
-    {
-      GNUNET_IDENTITY_ego_lookup_cancel(el);
-      el = NULL;
-    }
+  {
+    GNUNET_IDENTITY_ego_lookup_cancel (el);
+    el = NULL;
+  }
   if (NULL != q)
-    {
-      GNUNET_REVOCATION_query_cancel(q);
-      q = NULL;
-    }
+  {
+    GNUNET_REVOCATION_query_cancel (q);
+    q = NULL;
+  }
   if (NULL != h)
-    {
-      GNUNET_REVOCATION_revoke_cancel(h);
-      h = NULL;
-    }
+  {
+    GNUNET_REVOCATION_revoke_cancel (h);
+    h = NULL;
+  }
 }
 
 
@@ -118,28 +118,28 @@ do_shutdown(void *cls)
  * @param is_valid #GNUNET_YES if the key is still valid, #GNUNET_NO if not, #GNUNET_SYSERR on error
  */
 static void
-print_query_result(void *cls, int is_valid)
+print_query_result (void *cls, int is_valid)
 {
   q = NULL;
   switch (is_valid)
-    {
-    case GNUNET_YES:
-      fprintf(stdout, _("Key `%s' is valid\n"), test_ego);
-      break;
-
-    case GNUNET_NO:
-      fprintf(stdout, _("Key `%s' has been revoked\n"), test_ego);
-      break;
-
-    case GNUNET_SYSERR:
-      fprintf(stdout, "%s", _("Internal error\n"));
-      break;
-
-    default:
-      GNUNET_break(0);
-      break;
-    }
-  GNUNET_SCHEDULER_shutdown();
+  {
+  case GNUNET_YES:
+    fprintf (stdout, _ ("Key `%s' is valid\n"), test_ego);
+    break;
+
+  case GNUNET_NO:
+    fprintf (stdout, _ ("Key `%s' has been revoked\n"), test_ego);
+    break;
+
+  case GNUNET_SYSERR:
+    fprintf (stdout, "%s", _ ("Internal error\n"));
+    break;
+
+  default:
+    GNUNET_break (0);
+    break;
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -150,47 +150,48 @@ print_query_result(void *cls, int is_valid)
  * @param is_valid #GNUNET_YES if the key is still valid, #GNUNET_NO if not, #GNUNET_SYSERR on error
  */
 static void
-print_revocation_result(void *cls, int is_valid)
+print_revocation_result (void *cls, int is_valid)
 {
   h = NULL;
   switch (is_valid)
-    {
-    case GNUNET_YES:
-      if (NULL != revoke_ego)
-        fprintf(stdout,
-                _("Key for ego `%s' is still valid, revocation failed (!)\n"),
-                revoke_ego);
-      else
-        fprintf(stdout, "%s", _("Revocation failed (!)\n"));
-      break;
-
-    case GNUNET_NO:
-      if (NULL != revoke_ego)
-        fprintf(stdout,
-                _("Key for ego `%s' has been successfully revoked\n"),
-                revoke_ego);
-      else
-        fprintf(stdout, "%s", _("Revocation successful.\n"));
-      break;
-
-    case GNUNET_SYSERR:
-      fprintf(stdout,
-              "%s",
-              _("Internal error, key revocation might have failed\n"));
-      break;
-
-    default:
-      GNUNET_break(0);
-      break;
-    }
-  GNUNET_SCHEDULER_shutdown();
+  {
+  case GNUNET_YES:
+    if (NULL != revoke_ego)
+      fprintf (stdout,
+               _ ("Key for ego `%s' is still valid, revocation failed (!)\n"),
+               revoke_ego);
+    else
+      fprintf (stdout, "%s", _ ("Revocation failed (!)\n"));
+    break;
+
+  case GNUNET_NO:
+    if (NULL != revoke_ego)
+      fprintf (stdout,
+               _ ("Key for ego `%s' has been successfully revoked\n"),
+               revoke_ego);
+    else
+      fprintf (stdout, "%s", _ ("Revocation successful.\n"));
+    break;
+
+  case GNUNET_SYSERR:
+    fprintf (stdout,
+             "%s",
+             _ ("Internal error, key revocation might have failed\n"));
+    break;
+
+  default:
+    GNUNET_break (0);
+    break;
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
 /**
  * Data needed to perform a revocation.
  */
-struct RevocationData {
+struct RevocationData
+{
   /**
    * Public key.
    */
@@ -212,14 +213,14 @@ struct RevocationData {
  * Perform the revocation.
  */
 static void
-perform_revocation(const struct RevocationData *rd)
+perform_revocation (const struct RevocationData *rd)
 {
-  h = GNUNET_REVOCATION_revoke(cfg,
-                               &rd->key,
-                               &rd->sig,
-                               rd->pow,
-                               &print_revocation_result,
-                               NULL);
+  h = GNUNET_REVOCATION_revoke (cfg,
+                                &rd->key,
+                                &rd->sig,
+                                rd->pow,
+                                &print_revocation_result,
+                                NULL);
 }
 
 
@@ -230,16 +231,16 @@ perform_revocation(const struct RevocationData *rd)
  * @param rd data to sync
  */
 static void
-sync_rd(const struct RevocationData *rd)
+sync_rd (const struct RevocationData *rd)
 {
   if ((NULL != filename) &&
       (sizeof(struct RevocationData) ==
-       GNUNET_DISK_fn_write(filename,
-                            &rd,
-                            sizeof(rd),
-                            GNUNET_DISK_PERM_USER_READ |
-                            GNUNET_DISK_PERM_USER_WRITE)))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "write", filename);
+       GNUNET_DISK_fn_write (filename,
+                             &rd,
+                             sizeof(rd),
+                             GNUNET_DISK_PERM_USER_READ
+                             | GNUNET_DISK_PERM_USER_WRITE)))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "write", filename);
 }
 
 
@@ -249,17 +250,17 @@ sync_rd(const struct RevocationData *rd)
  * @param cls the `struct RevocationData`
  */
 static void
-calculate_pow_shutdown(void *cls)
+calculate_pow_shutdown (void *cls)
 {
   struct RevocationData *rd = cls;
 
   if (NULL != pow_task)
-    {
-      GNUNET_SCHEDULER_cancel(pow_task);
-      pow_task = NULL;
-    }
-  sync_rd(rd);
-  GNUNET_free(rd);
+  {
+    GNUNET_SCHEDULER_cancel (pow_task);
+    pow_task = NULL;
+  }
+  sync_rd (rd);
+  GNUNET_free (rd);
 }
 
 
@@ -269,53 +270,53 @@ calculate_pow_shutdown(void *cls)
  * @param cls the `struct RevocationData`
  */
 static void
-calculate_pow(void *cls)
+calculate_pow (void *cls)
 {
   struct RevocationData *rd = cls;
 
   /* store temporary results */
   pow_task = NULL;
   if (0 == (rd->pow % 128))
-    sync_rd(rd);
+    sync_rd (rd);
   /* display progress estimate */
   if ((0 == ((1 << matching_bits) / 100 / 50)) ||
       (0 == (rd->pow % ((1 << matching_bits) / 100 / 50))))
-    fprintf(stderr, "%s", ".");
+    fprintf (stderr, "%s", ".");
   if ((0 != rd->pow) && ((0 == ((1 << matching_bits) / 100)) ||
                          (0 == (rd->pow % ((1 << matching_bits) / 100)))))
-    fprintf(stderr,
-            " - @ %3u%% (estimate)\n",
-            (unsigned int)(rd->pow * 100) / (1 << matching_bits));
+    fprintf (stderr,
+             " - @ %3u%% (estimate)\n",
+             (unsigned int) (rd->pow * 100) / (1 << matching_bits));
   /* actually do POW calculation */
   rd->pow++;
-  if (GNUNET_OK == GNUNET_REVOCATION_check_pow(&rd->key,
-                                               rd->pow,
-                                               (unsigned int)matching_bits))
+  if (GNUNET_OK == GNUNET_REVOCATION_check_pow (&rd->key,
+                                                rd->pow,
+                                                (unsigned int) matching_bits))
+  {
+    if ((NULL != filename) &&
+        (sizeof(struct RevocationData) !=
+         GNUNET_DISK_fn_write (filename,
+                               rd,
+                               sizeof(struct RevocationData),
+                               GNUNET_DISK_PERM_USER_READ
+                               | GNUNET_DISK_PERM_USER_WRITE)))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "write", filename);
+    if (perform)
     {
-      if ((NULL != filename) &&
-          (sizeof(struct RevocationData) !=
-           GNUNET_DISK_fn_write(filename,
-                                rd,
-                                sizeof(struct RevocationData),
-                                GNUNET_DISK_PERM_USER_READ |
-                                GNUNET_DISK_PERM_USER_WRITE)))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "write", filename);
-      if (perform)
-        {
-          perform_revocation(rd);
-        }
-      else
-        {
-          fprintf(stderr, "%s", "\n");
-          fprintf(stderr,
-                  _("Revocation certificate for `%s' stored in `%s'\n"),
-                  revoke_ego,
-                  filename);
-          GNUNET_SCHEDULER_shutdown();
-        }
-      return;
+      perform_revocation (rd);
     }
-  pow_task = GNUNET_SCHEDULER_add_now(&calculate_pow, rd);
+    else
+    {
+      fprintf (stderr, "%s", "\n");
+      fprintf (stderr,
+               _ ("Revocation certificate for `%s' stored in `%s'\n"),
+               revoke_ego,
+               filename);
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    return;
+  }
+  pow_task = GNUNET_SCHEDULER_add_now (&calculate_pow, rd);
 }
 
 
@@ -326,57 +327,57 @@ calculate_pow(void *cls)
  * @param ego the ego, NULL if not found
  */
 static void
-ego_callback(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
+ego_callback (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
 {
   struct RevocationData *rd;
   struct GNUNET_CRYPTO_EcdsaPublicKey key;
 
   el = NULL;
   if (NULL == ego)
-    {
-      fprintf(stdout, _("Ego `%s' not found.\n"), revoke_ego);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_IDENTITY_ego_get_public_key(ego, &key);
-  rd = GNUNET_new(struct RevocationData);
-  if ((NULL != filename) && (GNUNET_YES == GNUNET_DISK_file_test(filename)) &&
+  {
+    fprintf (stdout, _ ("Ego `%s' not found.\n"), revoke_ego);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_IDENTITY_ego_get_public_key (ego, &key);
+  rd = GNUNET_new (struct RevocationData);
+  if ((NULL != filename) && (GNUNET_YES == GNUNET_DISK_file_test (filename)) &&
       (sizeof(struct RevocationData) ==
-       GNUNET_DISK_fn_read(filename, rd, sizeof(struct RevocationData))))
+       GNUNET_DISK_fn_read (filename, rd, sizeof(struct RevocationData))))
+  {
+    if (0 != GNUNET_memcmp (&rd->key, &key))
     {
-      if (0 != GNUNET_memcmp(&rd->key, &key))
-        {
-          fprintf(stderr,
-                  _("Error: revocation certificate in `%s' is not for `%s'\n"),
-                  filename,
-                  revoke_ego);
-          GNUNET_free(rd);
-          return;
-        }
+      fprintf (stderr,
+               _ ("Error: revocation certificate in `%s' is not for `%s'\n"),
+               filename,
+               revoke_ego);
+      GNUNET_free (rd);
+      return;
     }
+  }
   else
-    {
-      GNUNET_REVOCATION_sign_revocation(GNUNET_IDENTITY_ego_get_private_key(
-                                          ego),
-                                        &rd->sig);
-      rd->key = key;
-    }
+  {
+    GNUNET_REVOCATION_sign_revocation (GNUNET_IDENTITY_ego_get_private_key (
+                                         ego),
+                                       &rd->sig);
+    rd->key = key;
+  }
   if (GNUNET_YES ==
-      GNUNET_REVOCATION_check_pow(&key, rd->pow, (unsigned int)matching_bits))
-    {
-      fprintf(stderr, "%s", _("Revocation certificate ready\n"));
-      if (perform)
-        perform_revocation(rd);
-      else
-        GNUNET_SCHEDULER_shutdown();
-      GNUNET_free(rd);
-      return;
-    }
-  fprintf(stderr,
-          "%s",
-          _("Revocation certificate not ready, calculating proof of work\n"));
-  pow_task = GNUNET_SCHEDULER_add_now(&calculate_pow, rd);
-  GNUNET_SCHEDULER_add_shutdown(&calculate_pow_shutdown, rd);
+      GNUNET_REVOCATION_check_pow (&key, rd->pow, (unsigned int) matching_bits))
+  {
+    fprintf (stderr, "%s", _ ("Revocation certificate ready\n"));
+    if (perform)
+      perform_revocation (rd);
+    else
+      GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (rd);
+    return;
+  }
+  fprintf (stderr,
+           "%s",
+           _ ("Revocation certificate not ready, calculating proof of work\n"));
+  pow_task = GNUNET_SCHEDULER_add_now (&calculate_pow, rd);
+  GNUNET_SCHEDULER_add_shutdown (&calculate_pow_shutdown, rd);
 }
 
 
@@ -389,85 +390,85 @@ ego_callback(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
   struct RevocationData rd;
 
   cfg = c;
   if (NULL != test_ego)
+  {
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_ecdsa_public_key_from_string (test_ego,
+                                                    strlen (test_ego),
+                                                    &pk))
     {
-      if (GNUNET_OK !=
-          GNUNET_CRYPTO_ecdsa_public_key_from_string(test_ego,
-                                                     strlen(test_ego),
-                                                     &pk))
-        {
-          fprintf(stderr, _("Public key `%s' malformed\n"), test_ego);
-          return;
-        }
-      GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
-      q = GNUNET_REVOCATION_query(cfg, &pk, &print_query_result, NULL);
-      if (NULL != revoke_ego)
-        fprintf(
-          stderr,
-          "%s",
-          _(
-            "Testing and revoking at the same time is not allowed, only executing test.\n"));
+      fprintf (stderr, _ ("Public key `%s' malformed\n"), test_ego);
       return;
     }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                         "REVOCATION",
-                                                         "WORKBITS",
-                                                         &matching_bits))
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+    q = GNUNET_REVOCATION_query (cfg, &pk, &print_query_result, NULL);
+    if (NULL != revoke_ego)
+      fprintf (
+        stderr,
+        "%s",
+        _ (
+          "Testing and revoking at the same time is not allowed, only executing test.\n"));
+    return;
+  }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                          "REVOCATION",
+                                                          "WORKBITS",
+                                                          &matching_bits))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "REVOCATION",
+                               "WORKBITS");
+    return;
+  }
+  if (NULL != revoke_ego)
+  {
+    if (! perform && (NULL == filename))
     {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
-                                "REVOCATION",
-                                "WORKBITS");
+      fprintf (stderr,
+               "%s",
+               _ ("No filename to store revocation certificate given.\n"));
       return;
     }
-  if (NULL != revoke_ego)
+    /* main code here */
+    el = GNUNET_IDENTITY_ego_lookup (cfg, revoke_ego, &ego_callback, NULL);
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+    return;
+  }
+  if ((NULL != filename) && (perform))
+  {
+    if (sizeof(rd) != GNUNET_DISK_fn_read (filename, &rd, sizeof(rd)))
     {
-      if (!perform && (NULL == filename))
-        {
-          fprintf(stderr,
-                  "%s",
-                  _("No filename to store revocation certificate given.\n"));
-          return;
-        }
-      /* main code here */
-      el = GNUNET_IDENTITY_ego_lookup(cfg, revoke_ego, &ego_callback, NULL);
-      GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
+      fprintf (stderr,
+               _ ("Failed to read revocation certificate from `%s'\n"),
+               filename);
       return;
     }
-  if ((NULL != filename) && (perform))
+    GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+    if (GNUNET_YES !=
+        GNUNET_REVOCATION_check_pow (&rd.key,
+                                     rd.pow,
+                                     (unsigned int) matching_bits))
     {
-      if (sizeof(rd) != GNUNET_DISK_fn_read(filename, &rd, sizeof(rd)))
-        {
-          fprintf(stderr,
-                  _("Failed to read revocation certificate from `%s'\n"),
-                  filename);
-          return;
-        }
-      GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
-      if (GNUNET_YES !=
-          GNUNET_REVOCATION_check_pow(&rd.key,
-                                      rd.pow,
-                                      (unsigned int)matching_bits))
-        {
-          struct RevocationData *cp = GNUNET_new(struct RevocationData);
-
-          *cp = rd;
-          pow_task = GNUNET_SCHEDULER_add_now(&calculate_pow, cp);
-          GNUNET_SCHEDULER_add_shutdown(&calculate_pow_shutdown, cp);
-          return;
-        }
-      perform_revocation(&rd);
+      struct RevocationData *cp = GNUNET_new (struct RevocationData);
+
+      *cp = rd;
+      pow_task = GNUNET_SCHEDULER_add_now (&calculate_pow, cp);
+      GNUNET_SCHEDULER_add_shutdown (&calculate_pow_shutdown, cp);
       return;
     }
-  fprintf(stderr, "%s", _("No action specified. Nothing to do.\n"));
+    perform_revocation (&rd);
+    return;
+  }
+  fprintf (stderr, "%s", _ ("No action specified. Nothing to do.\n"));
 }
 
 
@@ -479,54 +480,54 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_string('f',
-                                "filename",
-                                "NAME",
-                                gettext_noop(
-                                  "use NAME for the name of the revocation file"),
-                                &filename),
-
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string ('f',
+                                 "filename",
+                                 "NAME",
+                                 gettext_noop (
+                                   "use NAME for the name of the revocation file"),
+                                 &filename),
+
+    GNUNET_GETOPT_option_string (
       'R',
       "revoke",
       "NAME",
-      gettext_noop(
+      gettext_noop (
         "revoke the private key associated for the the private key associated with the ego NAME "),
       &revoke_ego),
 
-    GNUNET_GETOPT_option_flag(
+    GNUNET_GETOPT_option_flag (
       'p',
       "perform",
-      gettext_noop(
+      gettext_noop (
         "actually perform revocation, otherwise we just do the precomputation"),
       &perform),
 
-    GNUNET_GETOPT_option_string('t',
-                                "test",
-                                "KEY",
-                                gettext_noop(
-                                  "test if the public key KEY has been revoked"),
-                                &test_ego),
+    GNUNET_GETOPT_option_string ('t',
+                                 "test",
+                                 "KEY",
+                                 gettext_noop (
+                                   "test if the public key KEY has been revoked"),
+                                 &test_ego),
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
-  ret = (GNUNET_OK == GNUNET_PROGRAM_run(argc,
-                                         argv,
-                                         "gnunet-revocation",
-                                         gettext_noop("help text"),
-                                         options,
-                                         &run,
-                                         NULL))
+  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
+                                          argv,
+                                          "gnunet-revocation",
+                                          gettext_noop ("help text"),
+                                          options,
+                                          &run,
+                                          NULL))
         ? ret
         : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }