* @param cls closure
*/
static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
{
- (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);
-}
-
-
-/**
- * Calculate the 'proof-of-work' hash (an expensive hash).
- *
- * @param buf data to hash
- * @param buf_len number of bytes in @a buf
- * @param result where to write the resulting hash
- */
-static void
-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));
+ (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);
}
* @return the number of leading zero bits.
*/
static unsigned int
-count_leading_zeroes(const struct GNUNET_HashCode *hash)
+count_leading_zeroes (const struct GNUNET_HashCode *hash)
{
unsigned int hash_count;
hash_count = 0;
- while (0 == GNUNET_CRYPTO_hash_get_bit(hash, hash_count))
+ while (0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count))
hash_count++;
return hash_count;
}
* @param tc task context
*/
static void
-find_proof(void *cls)
+find_proof (void *cls)
{
#define ROUND_SIZE 10
uint64_t counter;
- char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
- sizeof(uint64_t)] GNUNET_ALIGN;
+ char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey)
+ + sizeof(uint64_t)] GNUNET_ALIGN;
struct GNUNET_HashCode result;
unsigned int i;
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);
+ (void) cls;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "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();
+ timestamp = GNUNET_TIME_absolute_get ();
while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
+ {
+ GNUNET_memcpy (buf, &counter, sizeof(uint64_t));
+ GNUNET_CRYPTO_pow_hash ("gnunet-nse-proof-of-work",
+ buf,
+ sizeof(buf),
+ &result);
+ if (nse_work_required <= count_leading_zeroes (&result))
{
- GNUNET_memcpy(buf, &counter, sizeof(uint64_t));
- pow_hash(buf, sizeof(buf), &result);
- if (nse_work_required <= count_leading_zeroes(&result))
- {
- proof = counter;
- fprintf(stdout,
- "Proof of work found: %llu!\n",
- (unsigned long long)proof);
- GNUNET_SCHEDULER_shutdown();
- return;
- }
- counter++;
- i++;
- }
- elapsed = GNUNET_TIME_absolute_get_duration(timestamp);
- elapsed = GNUNET_TIME_relative_divide(elapsed, ROUND_SIZE);
- GNUNET_log(GNUNET_ERROR_TYPE_INFO,
- "Current: %llu [%s/proof]\n",
- (unsigned long long)counter,
- 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",
- (unsigned long long)counter);
- /* remember progress every 100 rounds */
proof = counter;
- shutdown_task(NULL);
+ fprintf (stdout,
+ "Proof of work found: %llu!\n",
+ (unsigned long long) proof);
+ GNUNET_SCHEDULER_shutdown ();
+ return;
}
+ counter++;
+ i++;
+ }
+ elapsed = GNUNET_TIME_absolute_get_duration (timestamp);
+ elapsed = GNUNET_TIME_relative_divide (elapsed, ROUND_SIZE);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Current: %llu [%s/proof]\n",
+ (unsigned long long) counter,
+ 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",
+ (unsigned long long) counter);
+ /* remember progress every 100 rounds */
+ proof = counter;
+ shutdown_task (NULL);
+ }
else
- {
- proof = counter;
- }
+ {
+ proof = counter;
+ }
proof_task =
- GNUNET_SCHEDULER_add_delayed_with_priority(proof_find_delay,
- GNUNET_SCHEDULER_PRIORITY_IDLE,
- &find_proof,
- NULL);
+ GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
+ GNUNET_SCHEDULER_PRIORITY_IDLE,
+ &find_proof,
+ NULL);
}
* @param cfg configuration
*/
static void
-run(void *cls,
- char *const *args,
- const char *cfgfile,
- const struct GNUNET_CONFIGURATION_Handle *config)
+run (void *cls,
+ char *const *args,
+ const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *config)
{
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
char *pids;
- (void)cls;
- (void)args;
- (void)cfgfile;
+ (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_SCHEDULER_shutdown();
- return;
- }
+ 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");
- return;
- }
- }
- 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);
- GNUNET_free(pkfn);
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+ "PEER",
+ "PRIVATE_KEY");
return;
}
- GNUNET_free(pkfn);
- 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_free(pids);
+ }
+ 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);
+ GNUNET_free (pkfn);
+ return;
+ }
+ GNUNET_free (pkfn);
+ 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_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_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"));
- GNUNET_SCHEDULER_shutdown();
- return;
- }
- else if (0 == nse_work_required)
- {
- GNUNET_SCHEDULER_shutdown();
- return;
- }
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
+ GNUNET_SCHEDULER_shutdown ();
+ return;
}
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Bits: %llu\n", nse_work_required);
+ if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
+ {
+ GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
+ "NSE",
+ "WORKBITS",
+ _ ("Value is too large.\n"));
+ GNUNET_SCHEDULER_shutdown ();
+ return;
+ }
+ else if (0 == nse_work_required)
+ {
+ GNUNET_SCHEDULER_shutdown ();
+ return;
+ }
+ }
+ 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));
+ 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);
+ GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+ &find_proof,
+ NULL);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}
* @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(
+ { GNUNET_GETOPT_option_ulong (
'b',
"bits",
"BITS",
- gettext_noop("number of bits to require for the proof of work"),
+ gettext_noop ("number of bits to require for the proof of work"),
&nse_work_required),
- GNUNET_GETOPT_option_filename(
+ GNUNET_GETOPT_option_filename (
'k',
"keyfile",
"FILE",
- gettext_noop("file with private key, otherwise default is used"),
+ gettext_noop ("file with private key, otherwise default is used"),
&pkfn),
- GNUNET_GETOPT_option_filename(
+ GNUNET_GETOPT_option_filename (
'o',
"outfile",
"FILE",
- gettext_noop("file with proof of work, otherwise default is used"),
+ 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_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))
+ 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);
+ GNUNET_free ((void *) argv);
+ GNUNET_free_non_null (pwfn);
return ret;
}
+
/* end of gnunet-scrypt.c */
projects / oweals / gnunet.git / blobdiff