1 files changed, 103 insertions, 110 deletions

diff --git a/src/util/gnunet-scrypt.c b/src/util/gnunet-scrypt.c
index 5e15eb16a..f4149a398 100644
--- a/src/util/gnunet-scrypt.c
+++ b/src/util/gnunet-scrypt.c
@@ -57,15 +57,13 @@ static char *pwfn;
 static void
 shutdown_task (void *cls)
 {
-  if (sizeof (proof) !=
-      GNUNET_DISK_fn_write (pwfn,
-                            &proof,
-                            sizeof (proof),
-                            GNUNET_DISK_PERM_USER_READ |
-                            GNUNET_DISK_PERM_USER_WRITE))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                              "write",
-                              pwfn);
+  (void) cls;
+  if (sizeof (proof) != GNUNET_DISK_fn_write (pwfn,
+                                              &proof,
+                                              sizeof (proof),
+                                              GNUNET_DISK_PERM_USER_READ |
+                                                GNUNET_DISK_PERM_USER_WRITE))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", pwfn);
 }
 
 
@@ -77,17 +75,18 @@ shutdown_task (void *cls)
  * @param result where to write the resulting hash
  */
 static void
-pow_hash (const void *buf,
-          size_t buf_len,
-          struct GNUNET_HashCode *result)
+pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
 {
-  GNUNET_break (0 ==
-  gcry_kdf_derive (buf, buf_len,
-                   GCRY_KDF_SCRYPT,
-                   1 /* subalgo */,
-                   "gnunet-proof-of-work", strlen ("gnunet-proof-of-work"),
-                   2 /* iterations; keep cost of individual op small */,
-                   sizeof (struct GNUNET_HashCode), result));
+  GNUNET_break (
+    0 == gcry_kdf_derive (buf,
+                          buf_len,
+                          GCRY_KDF_SCRYPT,
+                          1 /* subalgo */,
+                          "gnunet-proof-of-work",
+                          strlen ("gnunet-proof-of-work"),
+                          2 /* iterations; keep cost of individual op small */,
+                          sizeof (struct GNUNET_HashCode),
+                          result));
 }
 
 
@@ -118,7 +117,7 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash)
 static void
 find_proof (void *cls)
 {
-  #define ROUND_SIZE 10
+#define ROUND_SIZE 10
   uint64_t counter;
   char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
            sizeof (uint64_t)] GNUNET_ALIGN;
@@ -127,12 +126,14 @@ find_proof (void *cls)
   struct GNUNET_TIME_Absolute timestamp;
   struct GNUNET_TIME_Relative elapsed;
 
+  (void) cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got Proof of Work %llu\n",
-              (unsigned long long) proof);
+              "Got Proof of Work %llu\n",
+              (unsigned long long) proof);
   proof_task = NULL;
-  GNUNET_memcpy (&buf[sizeof (uint64_t)], &pub,
-          sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
+  GNUNET_memcpy (&buf[sizeof (uint64_t)],
+                 &pub,
+                 sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
   i = 0;
   counter = proof;
   timestamp = GNUNET_TIME_absolute_get ();
@@ -143,7 +144,8 @@ find_proof (void *cls)
     if (nse_work_required <= count_leading_zeroes (&result))
     {
       proof = counter;
-      FPRINTF (stdout, "Proof of work found: %llu!\n",
+      FPRINTF (stdout,
+               "Proof of work found: %llu!\n",
                (unsigned long long) proof);
       GNUNET_SCHEDULER_shutdown ();
       return;
@@ -159,7 +161,8 @@ find_proof (void *cls)
               GNUNET_STRINGS_relative_time_to_string (elapsed, 0));
   if (proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing proofs currently at %llu\n",
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Testing proofs currently at %llu\n",
                 (unsigned long long) counter);
     /* remember progress every 100 rounds */
     proof = counter;
@@ -171,8 +174,9 @@ find_proof (void *cls)
   }
   proof_task =
     GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
-                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                &find_proof, NULL);
+                                                GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                &find_proof,
+                                                NULL);
 }
 
 
@@ -193,54 +197,46 @@ run (void *cls,
   struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
   char *pids;
 
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
   cfg = config;
   /* load proof of work */
   if (NULL == pwfn)
   {
-    if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                 "NSE",
-                                                 "PROOFFILE",
-                                                 &pwfn))
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                              "NSE",
+                                                              "PROOFFILE",
+                                                              &pwfn))
     {
-      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                                 "NSE",
-                                 "PROOFFILE");
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
       GNUNET_SCHEDULER_shutdown ();
       return;
     }
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Proof of Work file: %s\n",
-              pwfn);
-  if ( (GNUNET_YES != GNUNET_DISK_file_test (pwfn)) ||
-       (sizeof (proof) !=
-        GNUNET_DISK_fn_read (pwfn, &proof, sizeof (proof))))
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Proof of Work file: %s\n", pwfn);
+  if ((GNUNET_YES != GNUNET_DISK_file_test (pwfn)) ||
+      (sizeof (proof) != GNUNET_DISK_fn_read (pwfn, &proof, sizeof (proof))))
     proof = 0;
 
   /* load private key */
   if (NULL == pkfn)
   {
-    if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                 "PEER",
-                                                 "PRIVATE_KEY",
-                                                 &pkfn))
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                              "PEER",
+                                                              "PRIVATE_KEY",
+                                                              &pkfn))
     {
       GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                  "PEER",
-                                 "PRIVATE_KEY");
+                                 "PRIVATE_KEY");
       return;
     }
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Private Key file: %s\n",
-              pkfn);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Private Key file: %s\n", pkfn);
   if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create_from_file (pkfn)))
   {
-    FPRINTF (stderr,
-             _("Loading hostkey from `%s' failed.\n"),
-             pkfn);
+    FPRINTF (stderr, _ ("Loading hostkey from `%s' failed.\n"), pkfn);
     GNUNET_free (pkfn);
     return;
   }
@@ -248,32 +244,27 @@ run (void *cls,
   GNUNET_CRYPTO_eddsa_key_get_public (pk, &pub);
   GNUNET_free (pk);
   pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Peer ID: %s\n",
-              pids);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer ID: %s\n", pids);
   GNUNET_free (pids);
 
   /* get target bit amount */
   if (0 == nse_work_required)
   {
-    if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_number (cfg,
-                                               "NSE",
-                                               "WORKBITS",
-                                               &nse_work_required))
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                            "NSE",
+                                                            "WORKBITS",
+                                                            &nse_work_required))
     {
-      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                                 "NSE",
-                                 "WORKBITS");
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
       GNUNET_SCHEDULER_shutdown ();
       return;
     }
     if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
     {
       GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
-                                 "NSE",
-                                 "WORKBITS",
-                                _("Value is too large.\n"));
+                                 "NSE",
+                                 "WORKBITS",
+                                 _ ("Value is too large.\n"));
       GNUNET_SCHEDULER_shutdown ();
       return;
     }
@@ -283,19 +274,16 @@ run (void *cls,
       return;
     }
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Bits: %llu\n",
-              nse_work_required);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Bits: %llu\n", nse_work_required);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Delay between tries: %s\n",
               GNUNET_STRINGS_relative_time_to_string (proof_find_delay, 1));
   proof_task =
     GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                        &find_proof,
-                                        NULL);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 NULL);
+                                        &find_proof,
+                                        NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 }
 
 
@@ -307,46 +295,51 @@ 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_ulong ('b',
-                                    "bits",
-                                    "BITS",
-                                    gettext_noop ("number of bits to require for the proof of work"),
-                                    &nse_work_required),
-    GNUNET_GETOPT_option_filename ('k',
-                                   "keyfile",
-                                   "FILE",
-                                   gettext_noop ("file with private key, otherwise default is used"),
-                                   &pkfn),
-    GNUNET_GETOPT_option_filename ('o',
-                                   "outfile",
-                                   "FILE",
-                                   gettext_noop ("file with proof of work, otherwise default is used"),
-                                   &pwfn),
-    GNUNET_GETOPT_option_relative_time ('t',
-                                            "timeout",
-                                            "TIME",
-                                            gettext_noop ("time to wait between calculations"),
-                                            &proof_find_delay),
-    GNUNET_GETOPT_OPTION_END
-  };
+  struct GNUNET_GETOPT_CommandLineOption options[] =
+    {GNUNET_GETOPT_option_ulong (
+       'b',
+       "bits",
+       "BITS",
+       gettext_noop ("number of bits to require for the proof of work"),
+       &nse_work_required),
+     GNUNET_GETOPT_option_filename (
+       'k',
+       "keyfile",
+       "FILE",
+       gettext_noop ("file with private key, otherwise default is used"),
+       &pkfn),
+     GNUNET_GETOPT_option_filename (
+       'o',
+       "outfile",
+       "FILE",
+       gettext_noop ("file with proof of work, otherwise default is used"),
+       &pwfn),
+     GNUNET_GETOPT_option_relative_time ('t',
+                                         "timeout",
+                                         "TIME",
+                                         gettext_noop (
+                                           "time to wait between calculations"),
+                                         &proof_find_delay),
+     GNUNET_GETOPT_OPTION_END};
   int ret;
 
-  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-scrypt [OPTIONS] prooffile",
-                             gettext_noop ("Manipulate GNUnet proof of work files"),
-                             options,
-                             &run,
-                             NULL)) ? 0 : 1;
-  GNUNET_free ((void*) argv);
+  ret =
+    (GNUNET_OK ==
+     GNUNET_PROGRAM_run (argc,
+                         argv,
+                         "gnunet-scrypt [OPTIONS] prooffile",
+                         gettext_noop ("Manipulate GNUnet proof of work files"),
+                         options,
+                         &run,
+                         NULL))
+      ? 0
+      : 1;
+  GNUNET_free ((void *) argv);
   GNUNET_free_non_null (pwfn);
   return ret;
 }