/**
* Task that triggers a NSE P2P transmission.
*
* @param cls the `struct NSEPeerEntry *`
*/
static void
transmit_task_cb (void *cls)
{
struct NSEPeerEntry *peer_entry = cls;
unsigned int idx;
struct GNUNET_MQ_Envelope *env;
peer_entry->transmit_task = NULL;
idx = estimate_index;
if (GNUNET_NO == peer_entry->previous_round)
{
idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
peer_entry->previous_round = GNUNET_YES;
peer_entry->transmit_task
= GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0),
&transmit_task_cb,
peer_entry);
}
if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
(NULL != proof_task))
{
GNUNET_STATISTICS_update (stats,
"# flood messages not generated (no proof yet)",
1,
GNUNET_NO);
return;
}
if (0 == ntohs (size_estimate_messages[idx].header.size))
{
GNUNET_STATISTICS_update (stats,
"# flood messages not generated (lack of history)",
1,
GNUNET_NO);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"In round %s, sending to `%s' estimate with %u bits\n",
GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (size_estimate_messages[idx].timestamp)),
GNUNET_i2s (peer_entry->id),
(unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
if (0 == ntohl (size_estimate_messages[idx].hop_count))
GNUNET_STATISTICS_update (stats,
"# flood messages started",
1,
GNUNET_NO);
GNUNET_STATISTICS_update (stats,
"# flood messages transmitted",
1,
GNUNET_NO);
#if ENABLE_NSE_HISTOGRAM
peer_entry->transmitted_messages++;
peer_entry->last_transmitted_size
= ntohl(size_estimate_messages[idx].matching_bits);
#endif
env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header);
GNUNET_MQ_send (peer_entry->mq,
env);
}
/**
* Calculate when we would like to send the next HELLO to this
* peer and ask for it.
*
* @param cls for which peer to schedule the HELLO
*/
static void
schedule_next_hello (void *cls)
{
struct Peer *pl = cls;
struct FindAdvHelloContext fah;
struct GNUNET_MQ_Envelope *env;
size_t want;
struct GNUNET_TIME_Relative delay;
struct GNUNET_HashCode hc;
pl->hello_delay_task = NULL;
GNUNET_assert (NULL != pl->mq);
/* find applicable HELLOs */
fah.peer = pl;
fah.result = NULL;
fah.max_size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;
fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;
GNUNET_CONTAINER_multipeermap_iterate (peers,
&find_advertisable_hello,
&fah);
pl->hello_delay_task =
GNUNET_SCHEDULER_add_delayed (fah.next_adv,
&schedule_next_hello,
pl);
if (NULL == fah.result)
return;
delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
if (0 != delay.rel_value_us)
return;
want = GNUNET_HELLO_size (fah.result->hello);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending HELLO with %u bytes",
(unsigned int) want);
env = GNUNET_MQ_msg_copy (&fah.result->hello->header);
GNUNET_MQ_send (pl->mq,
env);
/* avoid sending this one again soon */
GNUNET_CRYPTO_hash (&pl->pid,
sizeof (struct GNUNET_PeerIdentity),
&hc);
GNUNET_CONTAINER_bloomfilter_add (fah.result->filter,
&hc);
GNUNET_STATISTICS_update (stats,
gettext_noop ("# HELLO messages gossipped"),
1,
GNUNET_NO);
/* prepare to send the next one */
if (NULL != pl->hello_delay_task)
GNUNET_SCHEDULER_cancel (pl->hello_delay_task);
pl->next_hello_allowed
= GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
pl->hello_delay_task
= GNUNET_SCHEDULER_add_now (&schedule_next_hello,
pl);
}
/**
* Handler for START message from client, triggers an
* immediate current network estimate notification.
* Also, we remember the client for updates upon future
* estimate measurements.
*
* @param cls client who sent the message
* @param message the message received
*/
static void
handle_start (void *cls,
const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SERVICE_Client *client = cls;
struct GNUNET_MQ_Handle *mq;
struct GNUNET_NSE_ClientMessage em;
struct GNUNET_MQ_Envelope *env;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received START message from client\n");
mq = GNUNET_SERVICE_client_get_mq (client);
GNUNET_notification_context_add (nc,
mq);
setup_estimate_message (&em);
env = GNUNET_MQ_msg_copy (&em.header);
GNUNET_MQ_send (mq,
env);
GNUNET_SERVICE_client_continue (client);
}
