X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fnse%2Fgnunet-service-nse.c;h=b39891e7e5f30a5d1b818df64e4897c8c28ed7d4;hb=35cc1d8eeb2ead1fc57ff1a5d60fb4ca7d1d1216;hp=9a5933f47fab697da015de825536a93f1afc262b;hpb=5a663c3865727c909d6a1c05eef2a7e17a1c4bb4;p=oweals%2Fgnunet.git diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c index 9a5933f47..b39891e7e 100644 --- a/src/nse/gnunet-service-nse.c +++ b/src/nse/gnunet-service-nse.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors) + (C) 2009, 2010, 2011, 2012, 2013 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -44,7 +44,12 @@ #include "gnunet_statistics_service.h" #include "gnunet_core_service.h" #include "gnunet_nse_service.h" +#if ENABLE_NSE_HISTOGRAM +#include "gnunet_testbed_logger_service.h" +#endif #include "nse.h" +#include + /** * Should messages be delayed randomly? This option should be set to @@ -54,12 +59,9 @@ #define USE_RANDOM_DELAYS GNUNET_YES /** - * Should we generate a histogram with the time stamps of when we received - * NSE messages to disk? (for performance evaluation only, not useful in - * production). The associated code should also probably be removed - * once we're done with experiments. + * Generate extensive debug-level log messages? */ -#define ENABLE_HISTOGRAM GNUNET_NO +#define DEBUG_NSE GNUNET_NO /** * Over how many values do we calculate the weighted average? @@ -90,11 +92,11 @@ static struct GNUNET_TIME_Relative gnunet_nse_interval; */ static struct GNUNET_TIME_Relative proof_find_delay; -#if ENABLE_HISTOGRAM +#if ENABLE_NSE_HISTOGRAM /** * Handle for writing when we received messages to disk. */ -static struct GNUNET_BIO_WriteHandle *wh; +static struct GNUNET_TESTBED_LOGGER_Handle *lh; #endif @@ -126,7 +128,7 @@ struct NSEPeerEntry */ int previous_round; -#if ENABLE_HISTOGRAM +#if ENABLE_NSE_HISTOGRAM /** * Amount of messages received from this peer on this round. @@ -170,7 +172,7 @@ struct GNUNET_NSE_FloodMessage /** * Purpose. */ - struct GNUNET_CRYPTO_RsaSignaturePurpose purpose; + struct GNUNET_CRYPTO_EccSignaturePurpose purpose; /** * The current timestamp value (which all @@ -188,7 +190,7 @@ struct GNUNET_NSE_FloodMessage /** * Public key of the originator. */ - struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey; + struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey; /** * Proof of work, causing leading zeros when hashed with pkey. @@ -198,7 +200,7 @@ struct GNUNET_NSE_FloodMessage /** * Signature (over range specified in purpose). */ - struct GNUNET_CRYPTO_RsaSignature signature; + struct GNUNET_CRYPTO_EccSignature signature; }; GNUNET_NETWORK_STRUCT_END @@ -287,12 +289,12 @@ static struct GNUNET_TIME_Absolute current_timestamp; /** * The public key of this peer. */ -static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key; +static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded my_public_key; /** * The private key of this peer. */ -static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key; +static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key; /** * The peer identity of this peer. @@ -304,6 +306,11 @@ static struct GNUNET_PeerIdentity my_identity; */ static uint64_t my_proof; +/** + * Handle to this serivce's server. + */ +static struct GNUNET_SERVER_Handle *srv; + /** * Initialize a message to clients with the current network @@ -410,9 +417,7 @@ handle_start_message (void *cls, struct GNUNET_SERVER_Client *client, { struct GNUNET_NSE_ClientMessage em; -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n"); -#endif GNUNET_SERVER_notification_context_add (nc, client); setup_estimate_message (&em); GNUNET_SERVER_notification_context_unicast (nc, client, &em.header, @@ -457,11 +462,9 @@ get_delay_randomization (uint32_t matching_bits) d = get_matching_bits_delay (matching_bits); i = (uint32_t) (d / (double) (hop_count_max + 1)); -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Randomizing flood using latencies up to %u ms\n", (unsigned int) i); -#endif ret.rel_value = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1); return ret; #else @@ -470,6 +473,28 @@ get_delay_randomization (uint32_t matching_bits) } +/** + * Calculate the 'proof-of-work' hash (an expensive hash). + * + * @param buf data to hash + * @param buf_len number of bytes in '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)); +} + + /** * Get the number of matching bits that the given timestamp has to the given peer ID. * @@ -481,7 +506,7 @@ static uint32_t get_matching_bits (struct GNUNET_TIME_Absolute timestamp, const struct GNUNET_PeerIdentity *id) { - GNUNET_HashCode timestamp_hash; + struct GNUNET_HashCode timestamp_hash; GNUNET_CRYPTO_hash (×tamp.abs_value, sizeof (timestamp.abs_value), ×tamp_hash); @@ -514,11 +539,9 @@ get_transmit_delay (int round_offset) #else ret = GNUNET_TIME_UNIT_ZERO; #endif -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting previous round behind schedule in %llu ms\n", (unsigned long long) ret.rel_value); -#endif return ret; case 0: /* current round is based on best-known matching_bits */ @@ -527,13 +550,11 @@ get_transmit_delay (int round_offset) dist_delay = get_matching_bits_delay (matching_bits); dist_delay += get_delay_randomization (matching_bits).rel_value; ret.rel_value = (uint64_t) dist_delay; -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "For round %llu, delay for %u matching bits is %llu ms\n", (unsigned long long) current_timestamp.abs_value, (unsigned int) matching_bits, (unsigned long long) ret.rel_value); -#endif /* 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); @@ -569,14 +590,14 @@ transmit_ready (void *cls, size_t size, void *buf) unsigned int idx; peer_entry->th = NULL; - if (buf == NULL) + if (NULL == buf) { /* client disconnected */ return 0; } GNUNET_assert (size >= sizeof (struct GNUNET_NSE_FloodMessage)); idx = estimate_index; - if (peer_entry->previous_round == GNUNET_NO) + if (GNUNET_NO == peer_entry->previous_round) { idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE; peer_entry->previous_round = GNUNET_YES; @@ -584,7 +605,7 @@ transmit_ready (void *cls, size_t size, void *buf) GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0), &transmit_task_cb, peer_entry); } - if ((ntohl (size_estimate_messages[idx].hop_count) == 0) && + if ((0 == ntohl (size_estimate_messages[idx].hop_count)) && (GNUNET_SCHEDULER_NO_TASK != proof_task)) { GNUNET_STATISTICS_update (stats, @@ -592,14 +613,13 @@ transmit_ready (void *cls, size_t size, void *buf) 1, GNUNET_NO); return 0; } - if (ntohs (size_estimate_messages[idx].header.size) == 0) + if (0 == ntohs (size_estimate_messages[idx].header.size)) { GNUNET_STATISTICS_update (stats, "# flood messages not generated (lack of history)", 1, GNUNET_NO); return 0; } -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In round %llu, sending to `%s' estimate with %u bits\n", (unsigned long long) @@ -607,12 +627,11 @@ transmit_ready (void *cls, size_t size, void *buf) timestamp).abs_value, GNUNET_i2s (&peer_entry->id), (unsigned int) ntohl (size_estimate_messages[idx].matching_bits)); -#endif if (ntohl (size_estimate_messages[idx].hop_count) == 0) GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO); GNUNET_STATISTICS_update (stats, "# flood messages transmitted", 1, GNUNET_NO); -#if ENABLE_HISTOGRAM +#if ENABLE_NSE_HISTOGRAM peer_entry->transmitted_messages++; peer_entry->last_transmitted_size = ntohl(size_estimate_messages[idx].matching_bits); @@ -635,6 +654,7 @@ transmit_task_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) struct NSEPeerEntry *peer_entry = cls; peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK; + GNUNET_assert (NULL == peer_entry->th); peer_entry->th = GNUNET_CORE_notify_transmit_ready (coreAPI, GNUNET_NO, NSE_PRIORITY, @@ -670,7 +690,8 @@ update_network_size_estimate () * @param ts timestamp to use */ static void -setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts) +setup_flood_message (unsigned int slot, + struct GNUNET_TIME_Absolute ts) { struct GNUNET_NSE_FloodMessage *fm; uint32_t matching_bits; @@ -684,14 +705,14 @@ setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts) fm->purpose.size = htonl (sizeof (struct GNUNET_NSE_FloodMessage) - sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) - - sizeof (struct GNUNET_CRYPTO_RsaSignature)); + sizeof (struct GNUNET_CRYPTO_EccSignature)); fm->matching_bits = htonl (matching_bits); fm->timestamp = GNUNET_TIME_absolute_hton (ts); fm->pkey = my_public_key; fm->proof_of_work = my_proof; if (nse_work_required > 0) GNUNET_assert (GNUNET_OK == - GNUNET_CRYPTO_rsa_sign (my_private_key, &fm->purpose, + GNUNET_CRYPTO_ecc_sign (my_private_key, &fm->purpose, &fm->signature)); else memset (&fm->signature, 0, sizeof (fm->signature)); @@ -708,22 +729,24 @@ setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts) * @return GNUNET_OK (continue to iterate) */ static int -schedule_current_round (void *cls, const GNUNET_HashCode * key, void *value) +schedule_current_round (void *cls, + const struct GNUNET_HashCode * key, + void *value) { struct NSEPeerEntry *peer_entry = value; struct GNUNET_TIME_Relative delay; - if (peer_entry->th != NULL) + if (NULL != peer_entry->th) { peer_entry->previous_round = GNUNET_NO; return GNUNET_OK; } - if (peer_entry->transmit_task != GNUNET_SCHEDULER_NO_TASK) + if (GNUNET_SCHEDULER_NO_TASK != peer_entry->transmit_task) { GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); peer_entry->previous_round = GNUNET_NO; } -#if ENABLE_HISTOGRAM +#if ENABLE_NSE_HISTOGRAM if (peer_entry->received_messages > 1) GNUNET_STATISTICS_update(stats, "# extra messages", peer_entry->received_messages - 1, GNUNET_NO); @@ -800,7 +823,7 @@ update_flood_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) * @return the number of leading zero bits. */ static unsigned int -count_leading_zeroes (const GNUNET_HashCode * hash) +count_leading_zeroes (const struct GNUNET_HashCode * hash) { unsigned int hash_count; @@ -821,17 +844,17 @@ count_leading_zeroes (const GNUNET_HashCode * hash) * @return GNUNET_YES if valid, GNUNET_NO if not */ static int -check_proof_of_work (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *pkey, +check_proof_of_work (const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *pkey, uint64_t val) { - char buf[sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + - sizeof (val)]; - GNUNET_HashCode result; + char buf[sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) + + sizeof (val)] GNUNET_ALIGN; + struct GNUNET_HashCode result; memcpy (buf, &val, sizeof (val)); memcpy (&buf[sizeof (val)], pkey, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); - GNUNET_CRYPTO_hash (buf, sizeof (buf), &result); + sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)); + pow_hash (buf, sizeof (buf), &result); return (count_leading_zeroes (&result) >= nse_work_required) ? GNUNET_YES : GNUNET_NO; } @@ -869,27 +892,25 @@ find_proof (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { #define ROUND_SIZE 10 uint64_t counter; - char buf[sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) + - sizeof (uint64_t)]; - GNUNET_HashCode result; + char buf[sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) + + sizeof (uint64_t)] GNUNET_ALIGN; + struct GNUNET_HashCode result; unsigned int i; proof_task = GNUNET_SCHEDULER_NO_TASK; memcpy (&buf[sizeof (uint64_t)], &my_public_key, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)); + sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded)); i = 0; counter = my_proof; while ((counter != UINT64_MAX) && (i < ROUND_SIZE)) { memcpy (buf, &counter, sizeof (uint64_t)); - GNUNET_CRYPTO_hash (buf, sizeof (buf), &result); + pow_hash (buf, sizeof (buf), &result); if (nse_work_required <= count_leading_zeroes (&result)) { my_proof = counter; -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work found: %llu!\n", (unsigned long long) GNUNET_ntohll (counter)); -#endif write_proof (); setup_flood_message (estimate_index, current_timestamp); return; @@ -899,10 +920,8 @@ find_proof (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) } if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE)) { -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing proofs currently at %llu\n", (unsigned long long) counter); -#endif /* remember progress every 100 rounds */ my_proof = counter; write_proof (); @@ -935,7 +954,7 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) check_proof_of_work (&incoming_flood->pkey, incoming_flood->proof_of_work)) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("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); @@ -943,7 +962,7 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) } if ((nse_work_required > 0) && (GNUNET_OK != - GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND, + GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND, &incoming_flood->purpose, &incoming_flood->signature, &incoming_flood->pkey))) @@ -965,13 +984,13 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) * @return GNUNET_OK (continue to iterate) */ static int -update_flood_times (void *cls, const GNUNET_HashCode * key, void *value) +update_flood_times (void *cls, const struct GNUNET_HashCode * key, void *value) { struct NSEPeerEntry *exclude = cls; struct NSEPeerEntry *peer_entry = value; struct GNUNET_TIME_Relative delay; - if (peer_entry->th != NULL) + if (NULL != peer_entry->th) return GNUNET_OK; /* already active */ if (peer_entry == exclude) return GNUNET_OK; /* trigger of the update */ @@ -979,10 +998,14 @@ update_flood_times (void *cls, const GNUNET_HashCode * key, void *value) { /* still stuck in previous round, no point to update, check that * we are active here though... */ - GNUNET_break (peer_entry->transmit_task != GNUNET_SCHEDULER_NO_TASK); + if ( (GNUNET_SCHEDULER_NO_TASK == peer_entry->transmit_task) && + (NULL == peer_entry->th) ) + { + GNUNET_break (0); + } return GNUNET_OK; } - if (peer_entry->transmit_task != GNUNET_SCHEDULER_NO_TASK) + if (GNUNET_SCHEDULER_NO_TASK != peer_entry->transmit_task) { GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK; @@ -1000,14 +1023,10 @@ update_flood_times (void *cls, const GNUNET_HashCode * key, void *value) * @param cls closure unused * @param message message * @param peer peer identity this message is from (ignored) - * @param atsi performance data (ignored) - * @param atsi_count number of records in 'atsi' */ static int handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_MessageHeader *message, - const struct GNUNET_ATS_Information *atsi, - unsigned int atsi_count) + const struct GNUNET_MessageHeader *message) { const struct GNUNET_NSE_FloodMessage *incoming_flood; struct GNUNET_TIME_Absolute ts; @@ -1015,9 +1034,13 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, uint32_t matching_bits; unsigned int idx; -#if ENABLE_HISTOGRAM - if (NULL != wh) - GNUNET_BIO_write_int64 (wh, GNUNET_TIME_absolute_get ().abs_value); +#if ENABLE_NSE_HISTOGRAM + { + uint64_t t; + + t = GNUNET_TIME_absolute_get().abs_value; + GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t)); + } #endif incoming_flood = (const struct GNUNET_NSE_FloodMessage *) message; GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO); @@ -1029,14 +1052,13 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_PeerIdentity os; GNUNET_CRYPTO_hash (&incoming_flood->pkey, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &os.hashPubKey); GNUNET_snprintf (origin, sizeof (origin), "%s", GNUNET_i2s (&os)); GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Flood at %llu from `%s' via `%s' at `%s' with bits %u\n", - (unsigned long long) - GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp).abs_value, + "Flood at %s from `%s' via `%s' at `%s' with bits %u\n", + GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)), origin, pred, GNUNET_i2s (&my_identity), (unsigned int) matching_bits); } @@ -1048,7 +1070,7 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, GNUNET_break (0); return GNUNET_OK; } -#if ENABLE_HISTOGRAM +#if ENABLE_NSE_HISTOGRAM peer_entry->received_messages++; if (peer_entry->transmitted_messages > 0 && peer_entry->last_transmitted_size >= matching_bits) @@ -1108,7 +1130,7 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK; } - if (peer_entry->th != NULL) + if (NULL != peer_entry->th) { GNUNET_CORE_notify_transmit_ready_cancel (peer_entry->th); peer_entry->th = NULL; @@ -1117,8 +1139,9 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, } if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits)) { - if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES)) + if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES)) { peer_entry->previous_round = GNUNET_NO; + } /* push back our result now, that peer is spreading bad information... */ if (NULL == peer_entry->th) { @@ -1140,7 +1163,10 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, } GNUNET_assert (matching_bits > ntohl (size_estimate_messages[idx].matching_bits)); - /* cancel transmission from us to this peer for this round */ + /* Cancel transmission in the other direction, as this peer clearly has + * up-to-date information already. + */ + peer_entry->previous_round = GNUNET_YES; if (idx == estimate_index) { /* cancel any activity for current round */ @@ -1155,11 +1181,6 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, peer_entry->th = NULL; } } - else - { - /* cancel previous round only */ - peer_entry->previous_round = GNUNET_YES; - } size_estimate_messages[idx] = *incoming_flood; size_estimate_messages[idx].hop_count = htonl (ntohl (incoming_flood->hop_count) + 1); @@ -1181,24 +1202,19 @@ handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer, /** - * Method called whenever a peer connects. + * Method called whenever a peer connects. Sets up the PeerEntry and + * schedules the initial size info transmission to this peer. * * @param cls closure * @param peer peer identity this notification is about - * @param atsi performance data - * @param atsi_count number of records in 'atsi' */ static void -handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer, - const struct GNUNET_ATS_Information *atsi, - unsigned int atsi_count) +handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer) { struct NSEPeerEntry *peer_entry; -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s' connected to us\n", GNUNET_i2s (peer)); -#endif peer_entry = GNUNET_malloc (sizeof (struct NSEPeerEntry)); peer_entry->id = *peer; GNUNET_assert (GNUNET_OK == @@ -1208,12 +1224,13 @@ handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer, peer_entry->transmit_task = GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1), &transmit_task_cb, peer_entry); - GNUNET_STATISTICS_update (stats, "# peers", 1, GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO); } /** - * Method called whenever a peer disconnects. + * Method called whenever a peer disconnects. Deletes the PeerEntry and cancels + * any pending transmission requests to that peer. * * @param cls closure * @param peer peer identity this notification is about @@ -1223,10 +1240,8 @@ handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) { struct NSEPeerEntry *pos; -#if DEBUG_NSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s' disconnected from us\n", GNUNET_i2s (peer)); -#endif pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey); if (NULL == pos) { @@ -1236,18 +1251,37 @@ handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (peers, &peer->hashPubKey, pos)); - if (pos->transmit_task != GNUNET_SCHEDULER_NO_TASK) + if (pos->transmit_task != GNUNET_SCHEDULER_NO_TASK) { GNUNET_SCHEDULER_cancel (pos->transmit_task); - if (pos->th != NULL) + pos->transmit_task = GNUNET_SCHEDULER_NO_TASK; + } + if (NULL != pos->th) { GNUNET_CORE_notify_transmit_ready_cancel (pos->th); pos->th = NULL; } GNUNET_free (pos); - GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO); } +#if ENABLE_NSE_HISTOGRAM +/** + * Functions of this type are called to notify a successful transmission of the + * message to the logger service + * + * @param cls NULL + * @param size the amount of data sent + */ +static void +flush_comp_cb (void *cls, size_t size) +{ + GNUNET_TESTBED_LOGGER_disconnect (lh); + lh = NULL; +} +#endif + + /** * Task run during shutdown. * @@ -1257,48 +1291,46 @@ handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) static void shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - if (flood_task != GNUNET_SCHEDULER_NO_TASK) + if (GNUNET_SCHEDULER_NO_TASK != flood_task) { GNUNET_SCHEDULER_cancel (flood_task); flood_task = GNUNET_SCHEDULER_NO_TASK; } - if (proof_task != GNUNET_SCHEDULER_NO_TASK) + if (GNUNET_SCHEDULER_NO_TASK != proof_task) { GNUNET_SCHEDULER_cancel (proof_task); proof_task = GNUNET_SCHEDULER_NO_TASK; write_proof (); /* remember progress */ } - if (nc != NULL) + if (NULL != nc) { GNUNET_SERVER_notification_context_destroy (nc); nc = NULL; } - if (coreAPI != NULL) + if (NULL != coreAPI) { GNUNET_CORE_disconnect (coreAPI); coreAPI = NULL; } - if (stats != NULL) + if (NULL != stats) { GNUNET_STATISTICS_destroy (stats, GNUNET_NO); stats = NULL; } - if (peers != NULL) + if (NULL != peers) { GNUNET_CONTAINER_multihashmap_destroy (peers); peers = NULL; } - if (my_private_key != NULL) + if (NULL != my_private_key) { - GNUNET_CRYPTO_rsa_key_free (my_private_key); + GNUNET_CRYPTO_ecc_key_free (my_private_key); my_private_key = NULL; } -#if ENABLE_HISTOGRAM - if (wh != NULL) - { - GNUNET_BIO_write_close (wh); - wh = 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); #endif } @@ -1317,7 +1349,7 @@ core_init (void *cls, struct GNUNET_CORE_Handle *server, struct GNUNET_TIME_Absolute now; struct GNUNET_TIME_Absolute prev_time; - if (server == NULL) + if (NULL == server) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n"); GNUNET_SCHEDULER_shutdown (); @@ -1336,9 +1368,11 @@ core_init (void *cls, struct GNUNET_CORE_Handle *server, estimate_count = 0; if (GNUNET_YES == check_proof_of_work (&my_public_key, my_proof)) { + int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE; prev_time.abs_value = current_timestamp.abs_value - gnunet_nse_interval.rel_value; - setup_flood_message (estimate_index, prev_time); + setup_flood_message (idx, prev_time); + setup_flood_message (estimate_index, current_timestamp); estimate_count++; } flood_task = @@ -1356,12 +1390,10 @@ core_init (void *cls, struct GNUNET_CORE_Handle *server, * @param c configuration to use */ static void -run (void *cls, struct GNUNET_SERVER_Handle *server, +run (void *cls, + struct GNUNET_SERVER_Handle *server, const struct GNUNET_CONFIGURATION_Handle *c) { - char *keyfile; - char *proof; - static const struct GNUNET_SERVER_MessageHandler handlers[] = { {&handle_start_message, NULL, GNUNET_MESSAGE_TYPE_NSE_START, sizeof (struct GNUNET_MessageHeader)}, @@ -1372,8 +1404,12 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, sizeof (struct GNUNET_NSE_FloodMessage)}, {NULL, 0, 0} }; - cfg = c; + char *proof; + char *keyfile; + struct GNUNET_CRYPTO_EccPrivateKey *pk; + cfg = c; + srv = server; if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, "NSE", "INTERVAL", &gnunet_nse_interval)) || @@ -1386,39 +1422,46 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ - ("NSE service is lacking key configuration settings. Exiting.\n")); + ("%s service is lacking key configuration settings (%s). Exiting.\n"), + "NSE", "interval/workdelay/workbits"); GNUNET_SCHEDULER_shutdown (); return; } - if (nse_work_required >= sizeof (GNUNET_HashCode) * 8) + if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Invalid work requirement for NSE service. Exiting.\n")); GNUNET_SCHEDULER_shutdown (); return; } - - if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY", + GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY", &keyfile)) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ - ("NSE service is lacking key configuration settings. Exiting.\n")); + ("%s service is lacking key configuration settings (%s). Exiting.\n"), + "NSE", "peer/privatekey"); GNUNET_SCHEDULER_shutdown (); return; } - my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile); - GNUNET_free (keyfile); - if (my_private_key == NULL) +#if ENABLE_NSE_HISTOGRAM + if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg))) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("NSE service could not access hostkey. Exiting.\n")); + "Cannot connect to the testbed logger. Exiting.\n"); GNUNET_SCHEDULER_shutdown (); return; } - GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key); +#endif + + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, + NULL); + pk = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile); + GNUNET_free (keyfile); + GNUNET_assert (NULL != pk); + my_private_key = pk; + GNUNET_CRYPTO_ecc_key_get_public (my_private_key, &my_public_key); GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_identity.hashPubKey); if (GNUNET_OK != @@ -1427,11 +1470,8 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("NSE service is lacking key configuration settings. Exiting.\n")); - if (my_private_key != NULL) - { - GNUNET_CRYPTO_rsa_key_free (my_private_key); - my_private_key = NULL; - } + GNUNET_CRYPTO_ecc_key_free (my_private_key); + my_private_key = NULL; GNUNET_SCHEDULER_shutdown (); return; } @@ -1444,12 +1484,12 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, &find_proof, NULL); - peers = GNUNET_CONTAINER_multihashmap_create (128); - GNUNET_SERVER_add_handlers (server, handlers); - nc = GNUNET_SERVER_notification_context_create (server, 1); + peers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO); + GNUNET_SERVER_add_handlers (srv, handlers); + nc = GNUNET_SERVER_notification_context_create (srv, 1); /* Connect to core service and register core handlers */ coreAPI = GNUNET_CORE_connect (cfg, /* Main configuration */ - 1, NULL, /* Closure passed to functions */ + NULL, /* Closure passed to functions */ &core_init, /* Call core_init once connected */ &handle_core_connect, /* Handle connects */ &handle_core_disconnect, /* Handle disconnects */ @@ -1458,17 +1498,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, NULL, /* Don't want notified about all outbound messages */ GNUNET_NO, /* For header only outbound notification */ core_handlers); /* Register these handlers */ - GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, - NULL); -#if ENABLE_HISTOGRAM - if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "HISTOGRAM", &proof)) - { - wh = GNUNET_BIO_write_open (proof); - GNUNET_free (proof); - } -#endif - if (coreAPI == NULL) + if (NULL == coreAPI) { GNUNET_SCHEDULER_shutdown (); return; @@ -1478,7 +1508,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, /** - * The main function for the statistics service. + * The main function for the network size estimation service. * * @param argc number of arguments from the command line * @param argv command line arguments @@ -1492,4 +1522,21 @@ main (int argc, char *const *argv) &run, NULL)) ? 0 : 1; } + +#ifdef LINUX +#include + +/** + * MINIMIZE heap size (way below 128k) since this process doesn't need much. + */ +void __attribute__ ((constructor)) GNUNET_ARM_memory_init () +{ + mallopt (M_TRIM_THRESHOLD, 4 * 1024); + mallopt (M_TOP_PAD, 1 * 1024); + malloc_trim (0); +} +#endif + + + /* end of gnunet-service-nse.c */