static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static char *session_str = "gnunet-consensus/test";
char *topology;
int topology_cmp_result;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "testbed", "OVERLAY_TOPOLOGY", &topology))
{
fprintf (stderr,
"'OVERLAY_TOPOLOGY' not found in 'testbed' config section, "
"seems like you passed the wrong configuration file\n");
return;
}
topology_cmp_result = strcasecmp (topology, "NONE");
GNUNET_free (topology);
if (0 == topology_cmp_result)
{
fprintf (stderr,
"'OVERLAY_TOPOLOGY' set to 'NONE', "
"seems like you passed the wrong configuration file\n");
return;
}
if (num_peers < replication)
{
fprintf (stderr, "k must be <=n\n");
return;
}
start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), consensus_delay);
deadline = GNUNET_TIME_absolute_add (start, conclude_timeout);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"running gnunet-consensus\n");
GNUNET_CRYPTO_hash (session_str, strlen(session_str), &session_id);
(void) GNUNET_TESTBED_test_run ("gnunet-consensus",
cfgfile,
num_peers,
0,
controller_cb,
NULL,
test_master,
NULL);
}
static void
do_stop (void *cls)
{
struct GNUNET_TIME_Relative del;
char *fancy;
GNUNET_SCHEDULER_shutdown ();
if (0 ==
GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
TIMEOUT)).rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout during download, shutting down with error\n");
ok = 1;
}
else
{
del = GNUNET_TIME_absolute_get_duration (start_time);
if (del.rel_value_us == 0)
del.rel_value_us = 1;
fancy =
GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
1000000LL / del.rel_value_us);
FPRINTF (stdout,
"Download speed was %s/s\n",
fancy);
GNUNET_free (fancy);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Finished download, shutting down\n");
}
}
static void
do_stop (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *fn = cls;
if (0 ==
GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
TIMEOUT)).rel_value_us)
{
GNUNET_break (0);
ret = 1;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Finished download, shutting down\n",
(unsigned long long) FILESIZE);
}
if (NULL != fn)
{
GNUNET_DISK_directory_remove (fn);
GNUNET_free (fn);
}
GNUNET_SCHEDULER_shutdown ();
}
static int
client_receive_mst_cb (void *cls, void *client,
const struct GNUNET_MessageHeader *message)
{
struct Session *s = cls;
struct GNUNET_TIME_Relative delay;
if (GNUNET_YES != exist_session(p, s))
{
GNUNET_break (0);
return GNUNET_OK;
}
delay = http_plugin_receive (s, &s->target, message, s, s->addr, s->addrlen);
s->next_receive =
GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
if (GNUNET_TIME_absolute_get ().abs_value < s->next_receive.abs_value)
{
struct Plugin *plugin = s->plugin;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Client: peer `%s' address `%s' next read delayed for %llu ms\n",
GNUNET_i2s (&s->target), GNUNET_a2s (s->addr, s->addrlen),
delay);
}
return GNUNET_OK;
}
/**
* Adapter function called to destroy a connection to
* a service.
*
* @param cls closure
* @param op_result service handle returned from the connect adapter
*/
static void
session_disconnect_adapter (void *cls, void *op_result)
{
struct GNUNET_SECRETSHARING_Session **sp = cls;
unsigned int n = (sp - session_handles);
GNUNET_assert (*sp == session_handles[n]);
if (NULL != *sp)
{
GNUNET_SECRETSHARING_session_destroy (*sp);
*sp = NULL;
}
GNUNET_assert (NULL != connect_ops[n]);
connect_ops[n] = NULL;
if (GNUNET_YES == in_shutdown)
return;
// all peers received their secret
if (num_generated == num_peers)
{
int i;
// only do decryption if requested by the user
if (GNUNET_NO == decrypt)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
decrypt_start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
decrypt_deadline = GNUNET_TIME_absolute_add (decrypt_start, timeout);
// compute g^42 as the plaintext which we will decrypt and then
// cooperatively decrypt
GNUNET_SECRETSHARING_plaintext_generate_i (&reference_plaintext, 42);
GNUNET_SECRETSHARING_encrypt (&common_pubkey, &reference_plaintext, &ciphertext);
for (i = 0; i < num_peers; i++)
connect_ops[i] =
GNUNET_TESTBED_service_connect (NULL, peers[i], "secretsharing", &decrypt_connect_complete, NULL,
&decrypt_connect_adapter, &decrypt_disconnect_adapter, &decrypt_handles[i]);
}
}
/**
* Update our flood message to be sent (and our timestamps).
*
* @param cls unused
*/
static void
update_flood_message (void *cls)
{
struct GNUNET_TIME_Relative offset;
unsigned int i;
flood_task = NULL;
offset = GNUNET_TIME_absolute_get_remaining (next_timestamp);
if (0 != offset.rel_value_us)
{
/* somehow run early, delay more */
flood_task =
GNUNET_SCHEDULER_add_delayed (offset,
&update_flood_message,
NULL);
return;
}
estimate_index = (estimate_index + 1) % HISTORY_SIZE;
if (estimate_count < HISTORY_SIZE)
estimate_count++;
current_timestamp = next_timestamp;
next_timestamp =
GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
if ( (current_timestamp.abs_value_us ==
GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) &&
(get_matching_bits (current_timestamp, &my_identity) <
ntohl(next_message.matching_bits)) )
{
/* we received a message for this round way early, use it! */
size_estimate_messages[estimate_index] = next_message;
size_estimate_messages[estimate_index].hop_count =
htonl (1 + ntohl (next_message.hop_count));
}
else
setup_flood_message (estimate_index,
current_timestamp);
next_message.matching_bits = htonl (0); /* reset for 'next' round */
hop_count_max = 0;
for (i = 0; i < HISTORY_SIZE; i++)
hop_count_max = GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count),
hop_count_max);
GNUNET_CONTAINER_multipeermap_iterate (peers,
&schedule_current_round,
NULL);
flood_task
= GNUNET_SCHEDULER_add_at (next_timestamp,
&update_flood_message,
NULL);
}
/**
* Called on core init/fail.
*
* @param cls service closure
* @param identity the public identity of this peer
*/
static void
core_init (void *cls,
const struct GNUNET_PeerIdentity *identity)
{
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Absolute prev_time;
if (NULL == identity)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Connection to core FAILED!\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_assert (0 ==
memcmp (&my_identity,
identity,
sizeof (struct GNUNET_PeerIdentity)));
now = GNUNET_TIME_absolute_get ();
current_timestamp.abs_value_us =
(now.abs_value_us / gnunet_nse_interval.rel_value_us) *
gnunet_nse_interval.rel_value_us;
next_timestamp =
GNUNET_TIME_absolute_add (current_timestamp,
gnunet_nse_interval);
estimate_index = HISTORY_SIZE - 1;
estimate_count = 0;
if (GNUNET_YES ==
check_proof_of_work (&my_identity.public_key,
my_proof))
{
int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
prev_time.abs_value_us =
current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
setup_flood_message (idx,
prev_time);
setup_flood_message (estimate_index,
current_timestamp);
estimate_count++;
}
flood_task
= GNUNET_SCHEDULER_add_at (next_timestamp,
&update_flood_message,
NULL);
}
/**
* Callback for message stream tokenizer
*
* @param cls the session
* @param client not used
* @param message the message received
* @return always GNUNET_OK
*/
static int
client_receive_mst_cb (void *cls, void *client,
const struct GNUNET_MessageHeader *message)
{
struct Session *s = cls;
struct HTTP_Client_Plugin *plugin;
struct GNUNET_TIME_Relative delay;
struct GNUNET_ATS_Information atsi[2];
char *stat_txt;
if (GNUNET_YES != client_exist_session(p, s))
{
GNUNET_break (0);
return GNUNET_OK;
}
plugin = s->plugin;
atsi[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
atsi[0].value = htonl (1);
atsi[1].type = htonl (GNUNET_ATS_NETWORK_TYPE);
atsi[1].value = s->ats_address_network_type;
GNUNET_break (s->ats_address_network_type != ntohl (GNUNET_ATS_NET_UNSPECIFIED));
delay = s->plugin->env->receive (plugin->env->cls, &s->target, message,
(const struct GNUNET_ATS_Information *) &atsi, 2,
s, s->addr, s->addrlen);
GNUNET_asprintf (&stat_txt, "# bytes received via %s_client", plugin->protocol);
GNUNET_STATISTICS_update (plugin->env->stats,
stat_txt, ntohs(message->size), GNUNET_NO);
GNUNET_free (stat_txt);
s->next_receive =
GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
if (GNUNET_TIME_absolute_get ().abs_value < s->next_receive.abs_value)
{
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Client: peer `%s' address `%s' next read delayed for %llu ms\n",
GNUNET_i2s (&s->target), GNUNET_a2s (s->addr, s->addrlen),
delay);
}
client_reschedule_session_timeout (s);
return GNUNET_OK;
}
/**
* Get the transmission delay that should be applied for a
* particular round.
*
* @param round_offset -1 for the previous round (random delay between 0 and 50ms)
* 0 for the current round (based on our proximity to time key)
* @return delay that should be applied
*/
static struct GNUNET_TIME_Relative
get_transmit_delay (int round_offset)
{
struct GNUNET_TIME_Relative ret;
struct GNUNET_TIME_Absolute tgt;
double dist_delay;
uint32_t matching_bits;
switch (round_offset)
{
case -1:
/* previous round is randomized between 0 and 50 ms */
#if USE_RANDOM_DELAYS
ret.rel_value_us = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
50);
#else
ret = GNUNET_TIME_UNIT_ZERO;
#endif
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmitting previous round behind schedule in %s\n",
GNUNET_STRINGS_relative_time_to_string (ret,
GNUNET_YES));
return ret;
case 0:
/* current round is based on best-known matching_bits */
matching_bits =
ntohl (size_estimate_messages[estimate_index].matching_bits);
dist_delay = get_matching_bits_delay (matching_bits);
dist_delay += get_delay_randomization (matching_bits).rel_value_us;
ret.rel_value_us = (uint64_t) dist_delay;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"For round %s, delay for %u matching bits is %s\n",
GNUNET_STRINGS_absolute_time_to_string (current_timestamp),
(unsigned int) matching_bits,
GNUNET_STRINGS_relative_time_to_string (ret,
GNUNET_YES));
/* now consider round start time and add delay to it */
tgt = GNUNET_TIME_absolute_add (current_timestamp,
ret);
return GNUNET_TIME_absolute_get_remaining (tgt);
}
GNUNET_break (0);
return GNUNET_TIME_UNIT_FOREVER_REL;
}
static void
do_report (void *cls)
{
static int download_counter;
const char *type = cls;
struct GNUNET_TIME_Relative del;
char *fancy;
struct StatMaster *sm;
if (0 ==
GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
TIMEOUT)).rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout during download for type `%s', shutting down with error\n",
type);
ok = 1;
cleanup ();
return;
}
del = GNUNET_TIME_absolute_get_duration (start_time);
if (del.rel_value_us == 0)
del.rel_value_us = 1;
fancy =
GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
1000000LL / del.rel_value_us);
FPRINTF (stderr, "Download speed of type `%s' was %s/s\n", type, fancy);
GNUNET_free (fancy);
if (NUM_DAEMONS != ++download_counter)
return; /* more downloads to come */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Finished all downloads, getting statistics\n");
sm = GNUNET_new (struct StatMaster);
sm->op =
GNUNET_TESTBED_service_connect (NULL,
daemons[sm->daemon],
"statistics",
&stat_run, sm,
&statistics_connect_adapter,
&statistics_disconnect_adapter,
NULL);
}
int
main (int argc, char *argv[])
{
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_AbsoluteNBO nown;
struct GNUNET_TIME_Absolute future;
struct GNUNET_TIME_Absolute past;
struct GNUNET_TIME_Absolute last;
struct GNUNET_TIME_Absolute forever;
struct GNUNET_TIME_Absolute zero;
struct GNUNET_TIME_Relative rel;
struct GNUNET_TIME_Relative relForever;
struct GNUNET_TIME_Relative relUnit;
struct GNUNET_TIME_RelativeNBO reln;
unsigned int i;
GNUNET_log_setup ("test-time", "WARNING", NULL);
forever = GNUNET_TIME_UNIT_FOREVER_ABS;
relForever = GNUNET_TIME_UNIT_FOREVER_REL;
relUnit = GNUNET_TIME_UNIT_MILLISECONDS;
zero.abs_value_us = 0;
last = now = GNUNET_TIME_absolute_get ();
while (now.abs_value_us == last.abs_value_us)
now = GNUNET_TIME_absolute_get ();
GNUNET_assert (now.abs_value_us > last.abs_value_us);
/* test overflow checking in multiply */
rel = GNUNET_TIME_UNIT_MILLISECONDS;
GNUNET_log_skip (1, GNUNET_NO);
for (i = 0; i < 55; i++)
rel = GNUNET_TIME_relative_multiply (rel, 2);
GNUNET_log_skip (0, GNUNET_NO);
GNUNET_assert (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
/*check zero */
rel.rel_value_us = (UINT64_MAX) - 1024;
GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
GNUNET_TIME_relative_multiply (rel, 0).rel_value_us);
/* test infinity-check for relative to absolute */
GNUNET_log_skip (1, GNUNET_NO);
last = GNUNET_TIME_relative_to_absolute (rel);
GNUNET_assert (last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
GNUNET_log_skip (0, GNUNET_YES);
/* check relative to absolute */
rel.rel_value_us = 1000000;
GNUNET_assert (GNUNET_TIME_absolute_get ().abs_value_us <
GNUNET_TIME_relative_to_absolute (rel).abs_value_us);
/*check forever */
rel.rel_value_us = UINT64_MAX;
GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us ==
GNUNET_TIME_relative_to_absolute (rel).abs_value_us);
/* check overflow for r2a */
rel.rel_value_us = (UINT64_MAX) - 1024;
GNUNET_log_skip (1, GNUNET_NO);
last = GNUNET_TIME_relative_to_absolute (rel);
GNUNET_log_skip (0, GNUNET_NO);
GNUNET_assert (last.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us);
/* check overflow for relative add */
GNUNET_log_skip (1, GNUNET_NO);
rel = GNUNET_TIME_relative_add (rel, rel);
GNUNET_log_skip (0, GNUNET_NO);
GNUNET_assert (rel.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us);
GNUNET_log_skip (1, GNUNET_NO);
rel = GNUNET_TIME_relative_add (relForever, relForever);
GNUNET_log_skip (0, GNUNET_NO);
GNUNET_assert (rel.rel_value_us == relForever.rel_value_us);
GNUNET_log_skip (1, GNUNET_NO);
rel = GNUNET_TIME_relative_add (relUnit, relUnit);
GNUNET_assert (rel.rel_value_us == 2 * relUnit.rel_value_us);
/* check relation check in get_duration */
future.abs_value_us = now.abs_value_us + 1000000;
GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).rel_value_us ==
1000000);
GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).rel_value_us ==
0);
GNUNET_assert (GNUNET_TIME_absolute_get_difference (zero, forever).rel_value_us
== forever.abs_value_us);
past.abs_value_us = now.abs_value_us - 1000000;
rel = GNUNET_TIME_absolute_get_duration (future);
GNUNET_assert (rel.rel_value_us == 0);
rel = GNUNET_TIME_absolute_get_duration (past);
GNUNET_assert (rel.rel_value_us >= 1000000);
/* check get remaining */
rel = GNUNET_TIME_absolute_get_remaining (now);
GNUNET_assert (rel.rel_value_us == 0);
rel = GNUNET_TIME_absolute_get_remaining (past);
GNUNET_assert (rel.rel_value_us == 0);
rel = GNUNET_TIME_absolute_get_remaining (future);
GNUNET_assert (rel.rel_value_us > 0);
GNUNET_assert (rel.rel_value_us <= 1000000);
forever = GNUNET_TIME_UNIT_FOREVER_ABS;
GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
GNUNET_TIME_absolute_get_remaining (forever).rel_value_us);
/* check endianess */
reln = GNUNET_TIME_relative_hton (rel);
GNUNET_assert (rel.rel_value_us == GNUNET_TIME_relative_ntoh (reln).rel_value_us);
nown = GNUNET_TIME_absolute_hton (now);
GNUNET_assert (now.abs_value_us == GNUNET_TIME_absolute_ntoh (nown).abs_value_us);
/* check absolute addition */
future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_SECONDS);
GNUNET_assert (future.abs_value_us == now.abs_value_us + 1000 * 1000LL);
future = GNUNET_TIME_absolute_add (forever, GNUNET_TIME_UNIT_ZERO);
GNUNET_assert (future.abs_value_us == forever.abs_value_us);
rel.rel_value_us = (UINT64_MAX) - 1024;
now.abs_value_us = rel.rel_value_us;
future = GNUNET_TIME_absolute_add (now, rel);
GNUNET_assert (future.abs_value_us == forever.abs_value_us);
/* check zero */
future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_ZERO);
GNUNET_assert (future.abs_value_us == now.abs_value_us);
GNUNET_assert (forever.abs_value_us ==
GNUNET_TIME_absolute_subtract (forever,
GNUNET_TIME_UNIT_MINUTES).abs_value_us);
/*check absolute subtract */
now.abs_value_us = 50000;
rel.rel_value_us = 100000;
GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
(GNUNET_TIME_absolute_subtract (now, rel)).abs_value_us);
rel.rel_value_us = 10000;
GNUNET_assert (40000 == (GNUNET_TIME_absolute_subtract (now, rel)).abs_value_us);
/*check relative divide */
GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
(GNUNET_TIME_relative_divide (rel, 0)).rel_value_us);
rel = GNUNET_TIME_UNIT_FOREVER_REL;
GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
(GNUNET_TIME_relative_divide (rel, 2)).rel_value_us);
rel = GNUNET_TIME_relative_divide (relUnit, 2);
GNUNET_assert (rel.rel_value_us == relUnit.rel_value_us / 2);
/* check Return absolute time of 0ms */
zero = GNUNET_TIME_UNIT_ZERO_ABS;
/* check GNUNET_TIME_calculate_eta */
last.abs_value_us = GNUNET_TIME_absolute_get ().abs_value_us - 1024;
forever = GNUNET_TIME_UNIT_FOREVER_ABS;
forever.abs_value_us = forever.abs_value_us - 1024;
GNUNET_assert (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
GNUNET_TIME_calculate_eta (forever, 50000, 100000).rel_value_us);
/* check zero */
GNUNET_log_skip (1, GNUNET_NO);
GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
(GNUNET_TIME_calculate_eta (last, 60000, 50000)).rel_value_us);
GNUNET_log_skip (0, GNUNET_YES);
/*check forever */
GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
(GNUNET_TIME_calculate_eta (last, 0, 50000)).rel_value_us);
/*check relative subtract */
now = GNUNET_TIME_absolute_get ();
rel.rel_value_us = now.abs_value_us;
relForever.rel_value_us = rel.rel_value_us + 1024;
GNUNET_assert (1024 ==
GNUNET_TIME_relative_subtract (relForever, rel).rel_value_us);
/*check zero */
GNUNET_assert (GNUNET_TIME_UNIT_ZERO.rel_value_us ==
GNUNET_TIME_relative_subtract (rel, relForever).rel_value_us);
/*check forever */
rel.rel_value_us = UINT64_MAX;
GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us ==
GNUNET_TIME_relative_subtract (rel, relForever).rel_value_us);
/*check GNUNET_TIME_relative_min */
now = GNUNET_TIME_absolute_get ();
rel.rel_value_us = now.abs_value_us;
relForever.rel_value_us = rel.rel_value_us - 1024;
GNUNET_assert (relForever.rel_value_us ==
GNUNET_TIME_relative_min (rel, relForever).rel_value_us);
/*check GNUNET_TIME_relative_max */
GNUNET_assert (rel.rel_value_us ==
GNUNET_TIME_relative_max (rel, relForever).rel_value_us);
/*check GNUNET_TIME_absolute_min */
now = GNUNET_TIME_absolute_get ();
last.abs_value_us = now.abs_value_us - 1024;
GNUNET_assert (last.abs_value_us ==
GNUNET_TIME_absolute_min (now, last).abs_value_us);
/*check GNUNET_TIME_absolute_max */
GNUNET_assert (now.abs_value_us ==
GNUNET_TIME_absolute_max (now, last).abs_value_us);
return 0;
}
/**
* Encrypt data with the axolotl tunnel key.
*
* @param t Tunnel whose key to use.
* @param dst Destination with @a size bytes for the encrypted data.
* @param src Source of the plaintext. Can overlap with @c dst, must contain @a size bytes
* @param size Size of the buffers at @a src and @a dst
*/
static void
t_ax_encrypt (struct CadetTunnel *t,
void *dst,
const void *src,
size_t size)
{
struct GNUNET_CRYPTO_SymmetricSessionKey MK;
struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
struct CadetTunnelAxolotl *ax;
size_t out_size;
ax = &t->ax;
ax->ratchet_counter++;
if ( (GNUNET_YES == ax->ratchet_allowed) &&
( (ratchet_messages <= ax->ratchet_counter) ||
(0 == GNUNET_TIME_absolute_get_remaining (ax->ratchet_expiration).rel_value_us)) )
{
ax->ratchet_flag = GNUNET_YES;
}
if (GNUNET_YES == ax->ratchet_flag)
{
/* Advance ratchet */
struct GNUNET_CRYPTO_SymmetricSessionKey keys[3];
struct GNUNET_HashCode dh;
struct GNUNET_HashCode hmac;
static const char ctx[] = "axolotl ratchet";
new_ephemeral (t);
ax->HKs = ax->NHKs;
/* RK, NHKs, CKs = KDF( HMAC-HASH(RK, DH(DHRs, DHRr)) ) */
GNUNET_CRYPTO_ecc_ecdh (ax->DHRs,
&ax->DHRr,
&dh);
t_ax_hmac_hash (&ax->RK,
&hmac,
&dh,
sizeof (dh));
GNUNET_CRYPTO_kdf (keys, sizeof (keys),
ctx, sizeof (ctx),
&hmac, sizeof (hmac),
NULL);
ax->RK = keys[0];
ax->NHKs = keys[1];
ax->CKs = keys[2];
ax->PNs = ax->Ns;
ax->Ns = 0;
ax->ratchet_flag = GNUNET_NO;
ax->ratchet_allowed = GNUNET_NO;
ax->ratchet_counter = 0;
ax->ratchet_expiration
= GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(),
ratchet_time);
}
t_hmac_derive_key (&ax->CKs,
&MK,
"0",
1);
GNUNET_CRYPTO_symmetric_derive_iv (&iv,
&MK,
NULL, 0,
NULL);
out_size = GNUNET_CRYPTO_symmetric_encrypt (src,
size,
&MK,
&iv,
dst);
GNUNET_assert (size == out_size);
t_hmac_derive_key (&ax->CKs,
&ax->CKs,
"1",
1);
}
static size_t
send_ping_ready_cb (void *cls, size_t size, void *buf)
{
struct BenchmarkPartner *p = cls;
static char msgbuf[TEST_MESSAGE_SIZE];
struct GNUNET_MessageHeader *msg;
struct GNUNET_TIME_Relative delay;
if (NULL == buf)
{
GNUNET_break (0);
return 0;
}
if (size < TEST_MESSAGE_SIZE)
{
GNUNET_break (0);
return 0;
}
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Master [%u]: Sending PING to [%u]\n",
p->me->no, p->dest->no);
if (top->test_core)
{
if (NULL == p->cth)
{
GNUNET_break (0);
}
p->cth = NULL;
}
else
{
if (NULL == p->tth)
{
GNUNET_break (0);
}
p->tth = NULL;
}
msg = (struct GNUNET_MessageHeader *) &msgbuf;
memset (&msgbuf, 'a', TEST_MESSAGE_SIZE);
msg->type = htons (TEST_MESSAGE_TYPE_PING);
msg->size = htons (TEST_MESSAGE_SIZE);
memcpy (buf, msg, TEST_MESSAGE_SIZE);
p->messages_sent++;
p->bytes_sent += TEST_MESSAGE_SIZE;
p->me->total_messages_sent++;
p->me->total_bytes_sent += TEST_MESSAGE_SIZE;
if (NULL == p->tg)
{
GNUNET_break (0);
return TEST_MESSAGE_SIZE;
}
delay = get_delay (p->tg);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Delay for next transmission %llu ms\n",
(long long unsigned int) delay.rel_value_us / 1000);
p->tg->next_ping_transmission = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(),
delay);
return TEST_MESSAGE_SIZE;
}
static void
secret_ready_cb (void *cls,
struct GNUNET_SECRETSHARING_Share *my_share,
struct GNUNET_SECRETSHARING_PublicKey *public_key,
unsigned int num_ready_peers,
struct GNUNET_PeerIdentity *ready_peers)
{
struct GNUNET_SECRETSHARING_Session **sp = cls;
unsigned int n = sp - session_handles;
char pubkey_str[1024];
char *ret;
num_generated++;
*sp = NULL;
shares[n] = my_share;
if (NULL == my_share)
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation failed for peer #%u\n", n);
}
else
{
ret = GNUNET_STRINGS_data_to_string (public_key, sizeof *public_key, pubkey_str, 1024);
GNUNET_assert (NULL != ret);
*ret = '\0';
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "key generation successful for peer #%u, pubkey %s\n", n,
pubkey_str);
/* we're the first to get the key -> store it */
if (num_generated == 1)
{
common_pubkey = *public_key;
}
else if (0 != memcmp (public_key, &common_pubkey, sizeof (struct GNUNET_SECRETSHARING_PublicKey)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "generated public keys do not match\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
}
// FIXME: destroy testbed operation
if (num_generated == num_peers)
{
int i;
if (GNUNET_NO == decrypt)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
decrypt_start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
decrypt_deadline = GNUNET_TIME_absolute_add (decrypt_start, timeout);
// compute g^42
GNUNET_SECRETSHARING_plaintext_generate_i (&reference_plaintext, 42);
GNUNET_SECRETSHARING_encrypt (&common_pubkey, &reference_plaintext, &ciphertext);
// FIXME: store the ops somewhere!
for (i = 0; i < num_peers; i++)
GNUNET_TESTBED_service_connect (NULL, peers[i], "secretsharing", &decrypt_connect_complete, NULL,
&decrypt_connect_adapter, &decrypt_disconnect_adapter, &decrypt_handles[i]);
}
}
/**
* Find a "good" address to use for a peer. If we already have an existing
* address, we stick to it. Otherwise, we pick by lowest distance and then
* by lowest latency.
*
* @param cls the 'struct ATS_Address**' where we store the result
* @param key unused
* @param value another 'struct ATS_Address*' to consider using
* @return GNUNET_OK (continue to iterate)
*/
static int
find_address_it (void *cls, const GNUNET_HashCode * key, void *value)
{
struct ATS_Address **ap = cls;
struct ATS_Address *aa = (struct ATS_Address *) value;
struct ATS_Address *ab = *ap;
struct GNUNET_TIME_Absolute now;
now = GNUNET_TIME_absolute_get();
if (aa->blocked_until.abs_value == GNUNET_TIME_absolute_max (now, aa->blocked_until).abs_value)
{
/* This address is blocked for suggestion */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Address %p blocked for suggestion for %llu ms \n",
aa,
GNUNET_TIME_absolute_get_difference(now, aa->blocked_until).rel_value);
return GNUNET_OK;
}
aa->block_interval = GNUNET_TIME_relative_add (aa->block_interval, ATS_BLOCKING_DELTA);
aa->blocked_until = GNUNET_TIME_absolute_add (now, aa->block_interval);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Address %p ready for suggestion, block interval now %llu \n", aa, aa->block_interval);
/* FIXME this is a hack */
if (NULL != ab)
{
if ((0 == strcmp (ab->plugin, "tcp")) &&
(0 == strcmp (aa->plugin, "tcp")))
{
if ((0 != ab->addr_len) &&
(0 == aa->addr_len))
{
/* saved address was an outbound address, but we have an inbound address */
*ap = aa;
return GNUNET_OK;
}
if (0 == ab->addr_len)
{
/* saved address was an inbound address, so do not overwrite */
return GNUNET_OK;
}
}
}
/* FIXME end of hack */
if (NULL == ab)
{
*ap = aa;
return GNUNET_OK;
}
if ((ntohl (ab->assigned_bw_in.value__) == 0) &&
(ntohl (aa->assigned_bw_in.value__) > 0))
{
/* stick to existing connection */
*ap = aa;
return GNUNET_OK;
}
if (ab->atsp_distance > aa->atsp_distance)
{
/* user shorter distance */
*ap = aa;
return GNUNET_OK;
}
if (ab->atsp_latency.rel_value > aa->atsp_latency.rel_value)
{
/* user lower latency */
*ap = aa;
return GNUNET_OK;
}
/* don't care */
return GNUNET_OK;
}
/**
* Sign name and records
*
* @param key the private key
* @param expire block expiration
* @param label the name for the records
* @param rd record data
* @param rd_count number of records
* @return NULL on error (block too large)
*/
struct GNUNET_GNSRECORD_Block *
GNUNET_GNSRECORD_block_create (const struct GNUNET_CRYPTO_EcdsaPrivateKey *key,
struct GNUNET_TIME_Absolute expire,
const char *label,
const struct GNUNET_GNSRECORD_Data *rd,
unsigned int rd_count)
{
size_t payload_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
char payload[sizeof (uint32_t) + payload_len];
struct GNUNET_GNSRECORD_Block *block;
struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
struct GNUNET_CRYPTO_EcdsaPrivateKey *dkey;
struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
struct GNUNET_CRYPTO_SymmetricSessionKey skey;
struct GNUNET_GNSRECORD_Data rdc[rd_count];
uint32_t rd_count_nbo;
unsigned int i;
struct GNUNET_TIME_Absolute now;
if (payload_len > GNUNET_GNSRECORD_MAX_BLOCK_SIZE)
return NULL;
/* convert relative to absolute times */
now = GNUNET_TIME_absolute_get ();
for (i=0;i<rd_count;i++)
{
rdc[i] = rd[i];
if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
{
struct GNUNET_TIME_Relative t;
/* encrypted blocks must never have relative expiration times, convert! */
rdc[i].flags &= ~GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
t.rel_value_us = rdc[i].expiration_time;
rdc[i].expiration_time = GNUNET_TIME_absolute_add (now, t).abs_value_us;
}
}
/* serialize */
rd_count_nbo = htonl (rd_count);
memcpy (payload, &rd_count_nbo, sizeof (uint32_t));
GNUNET_assert (payload_len ==
GNUNET_GNSRECORD_records_serialize (rd_count, rdc,
payload_len, &payload[sizeof (uint32_t)]));
block = GNUNET_malloc (sizeof (struct GNUNET_GNSRECORD_Block) +
sizeof (uint32_t) + payload_len);
block->purpose.size = htonl (sizeof (uint32_t) + payload_len +
sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
sizeof (struct GNUNET_TIME_AbsoluteNBO));
block->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_GNS_RECORD_SIGN);
block->expiration_time = GNUNET_TIME_absolute_hton (expire);
/* encrypt and sign */
dkey = GNUNET_CRYPTO_ecdsa_private_key_derive (key,
label,
"gns");
GNUNET_CRYPTO_ecdsa_key_get_public (dkey,
&block->derived_key);
GNUNET_CRYPTO_ecdsa_key_get_public (key,
&pkey);
derive_block_aes_key (&iv, &skey, label, &pkey);
GNUNET_break (payload_len + sizeof (uint32_t) ==
GNUNET_CRYPTO_symmetric_encrypt (payload, payload_len + sizeof (uint32_t),
&skey, &iv,
&block[1]));
if (GNUNET_OK !=
GNUNET_CRYPTO_ecdsa_sign (dkey,
&block->purpose,
&block->signature))
{
GNUNET_break (0);
GNUNET_free (dkey);
GNUNET_free (block);
return NULL;
}
GNUNET_free (dkey);
return block;
}
/**
* Periodically announce self id in the DHT
*
* @param cls closure
*/
static void
announce_id (void *cls)
{
struct GNUNET_HashCode phash;
const struct GNUNET_HELLO_Message *hello;
size_t size;
struct GNUNET_TIME_Absolute expiration;
struct GNUNET_TIME_Relative next_put;
hello = GCH_get_mine ();
size = (NULL != hello) ? GNUNET_HELLO_size (hello) : 0;
if (0 == size)
{
expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
announce_delay);
announce_delay = GNUNET_TIME_STD_BACKOFF (announce_delay);
}
else
{
expiration = GNUNET_HELLO_get_last_expiration (hello);
announce_delay = GNUNET_TIME_UNIT_SECONDS;
}
/* Call again in id_announce_time, unless HELLO expires first,
* but wait at least 1s. */
next_put
= GNUNET_TIME_absolute_get_remaining (expiration);
next_put
= GNUNET_TIME_relative_min (next_put,
id_announce_time);
next_put
= GNUNET_TIME_relative_max (next_put,
GNUNET_TIME_UNIT_SECONDS);
announce_id_task
= GNUNET_SCHEDULER_add_delayed (next_put,
&announce_id,
cls);
GNUNET_STATISTICS_update (stats,
"# DHT announce",
1,
GNUNET_NO);
memset (&phash,
0,
sizeof (phash));
GNUNET_memcpy (&phash,
&my_full_id,
sizeof (my_full_id));
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Announcing my HELLO (%u bytes) in the DHT\n",
size);
GNUNET_DHT_put (dht_handle, /* DHT handle */
&phash, /* Key to use */
dht_replication_level, /* Replication level */
GNUNET_DHT_RO_RECORD_ROUTE
| GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, /* DHT options */
GNUNET_BLOCK_TYPE_DHT_HELLO, /* Block type */
size, /* Size of the data */
(const char *) hello, /* Data itself */
expiration, /* Data expiration */
NULL, /* Continuation */
NULL); /* Continuation closure */
}