/**
* Message priority to use.
*/
-#define NSE_PRIORITY 5
+#define NSE_PRIORITY GNUNET_CORE_PRIO_CRITICAL_CONTROL
#if FREEBSD
#define log2(a) (log(a)/log(2))
static struct GNUNET_TIME_Relative proof_find_delay;
#if ENABLE_NSE_HISTOGRAM
+
+/**
+ * Handle to test if testbed logger service is running or not
+ */
+struct GNUNET_CLIENT_TestHandle *logger_test;
+
/**
* Handle for writing when we received messages to disk.
*/
static struct GNUNET_TESTBED_LOGGER_Handle *lh;
+
+/**
+ * Handle for writing message received timestamp information to disk.
+ */
+static struct GNUNET_BIO_WriteHandle *histogram;
+
#endif
/**
* Signature (over range specified in purpose).
*/
- struct GNUNET_CRYPTO_EccSignature signature;
+ struct GNUNET_CRYPTO_EddsaSignature signature;
};
GNUNET_NETWORK_STRUCT_END
/**
* The private key of this peer.
*/
-static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
/**
* The peer identity of this peer.
GNUNET_assert (NULL == peer_entry->th);
peer_entry->th =
- GNUNET_CORE_notify_transmit_ready (core_api, GNUNET_NO, NSE_PRIORITY,
+ GNUNET_CORE_notify_transmit_ready (core_api, GNUNET_NO,
+ NSE_PRIORITY,
GNUNET_TIME_UNIT_FOREVER_REL,
&peer_entry->id,
sizeof (struct
fm->purpose.size =
htonl (sizeof (struct GNUNET_NSE_FloodMessage) -
sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) -
- sizeof (struct GNUNET_CRYPTO_EccSignature));
+ sizeof (struct GNUNET_CRYPTO_EddsaSignature));
fm->matching_bits = htonl (matching_bits);
fm->timestamp = GNUNET_TIME_absolute_hton (ts);
fm->origin = my_identity;
fm->proof_of_work = my_proof;
if (nse_work_required > 0)
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_ecc_sign (my_private_key, &fm->purpose,
+ GNUNET_CRYPTO_eddsa_sign (my_private_key, &fm->purpose,
&fm->signature));
else
memset (&fm->signature, 0, sizeof (fm->signature));
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;
}
* @return #GNUNET_YES if valid, #GNUNET_NO if not
*/
static int
-check_proof_of_work (const struct GNUNET_CRYPTO_EccPublicSignKey *pkey,
+check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
uint64_t val)
{
- char buf[sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
+ char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
sizeof (val)] GNUNET_ALIGN;
struct GNUNET_HashCode result;
memcpy (buf, &val, sizeof (val));
memcpy (&buf[sizeof (val)], pkey,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
+ sizeof (struct GNUNET_CRYPTO_EddsaPublicKey));
pow_hash (buf, sizeof (buf), &result);
return (count_leading_zeroes (&result) >=
nse_work_required) ? GNUNET_YES : GNUNET_NO;
{
#define ROUND_SIZE 10
uint64_t counter;
- char buf[sizeof (struct GNUNET_CRYPTO_EccPublicSignKey) +
+ char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) +
sizeof (uint64_t)] GNUNET_ALIGN;
struct GNUNET_HashCode result;
unsigned int i;
check_proof_of_work (&incoming_flood->origin.public_key,
incoming_flood->proof_of_work))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work invalid: %llu!\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Proof of work invalid: %llu!\n",
(unsigned long long)
GNUNET_ntohll (incoming_flood->proof_of_work));
GNUNET_break_op (0);
}
if ((nse_work_required > 0) &&
(GNUNET_OK !=
- GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
+ GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
&incoming_flood->purpose,
&incoming_flood->signature,
&incoming_flood->origin.public_key)))
uint64_t t;
t = GNUNET_TIME_absolute_get().abs_value_us;
- GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t));
+ if (NULL != lh)
+ GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t));
+ if (NULL != histogram)
+ GNUNET_BIO_write_int64 (histogram, t);
}
#endif
incoming_flood = (const struct GNUNET_NSE_FloodMessage *) message;
my_private_key = NULL;
}
#if ENABLE_NSE_HISTOGRAM
- struct GNUNET_TIME_Relative timeout;
- timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
- GNUNET_TESTBED_LOGGER_flush (lh, timeout, &flush_comp_cb, NULL);
+ if (NULL != logger_test)
+ {
+ GNUNET_CLIENT_service_test_cancel (logger_test);
+ logger_test = NULL;
+ }
+ if (NULL != lh)
+ {
+ struct GNUNET_TIME_Relative timeout;
+ timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
+ GNUNET_TESTBED_LOGGER_flush (lh, timeout, &flush_comp_cb, NULL);
+ }
+ if (NULL != histogram)
+ {
+ GNUNET_BIO_write_close (histogram);
+ histogram = NULL;
+ }
#endif
}
NULL);
}
+#if ENABLE_NSE_HISTOGRAM
+/**
+ * Function called with the status of the testbed logger service
+ *
+ * @param cls NULL
+ * @param status GNUNET_YES if the service is running,
+ * GNUNET_NO if the service is not running
+ * GNUNET_SYSERR if the configuration is invalid
+ */
+static void
+status_cb (void *cls, int status)
+{
+ logger_test = NULL;
+ if (GNUNET_YES != status)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
+ return;
+ }
+ if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Cannot connect to the testbed logger. Exiting.\n");
+ GNUNET_SCHEDULER_shutdown ();
+ }
+}
+#endif
+
/**
* Handle network size estimate clients.
{NULL, 0, 0}
};
char *proof;
- struct GNUNET_CRYPTO_EccPrivateKey *pk;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
cfg = c;
srv = server;
}
#if ENABLE_NSE_HISTOGRAM
- if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot connect to the testbed logger. Exiting.\n");
- GNUNET_SCHEDULER_shutdown ();
- return;
+ char *histogram_dir;
+ char *histogram_fn;
+
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "HISTOGRAM_DIR",
+ &histogram_dir))
+ {
+ GNUNET_assert (0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps",
+ histogram_dir));
+ GNUNET_free (histogram_dir);
+ histogram = GNUNET_BIO_write_open (histogram_fn);
+ GNUNET_free (histogram_fn);
+ if (NULL == histogram)
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to open histogram file\n");
+ }
+ logger_test =
+ GNUNET_CLIENT_service_test ("testbed-logger", cfg,
+ GNUNET_TIME_UNIT_SECONDS,
+ &status_cb, NULL);
+
}
#endif
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
- pk = GNUNET_CRYPTO_ecc_key_create_from_configuration (cfg);
+ pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
GNUNET_assert (NULL != pk);
my_private_key = pk;
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key,
+ GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
&my_identity.public_key);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _
- ("NSE service is lacking key configuration settings. Exiting.\n"));
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
GNUNET_free (my_private_key);
my_private_key = NULL;
GNUNET_SCHEDULER_shutdown ();