aboutsummaryrefslogtreecommitdiff
path: root/src/nse/gnunet-service-nse.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/nse/gnunet-service-nse.c')
-rw-r--r--src/nse/gnunet-service-nse.c1300
1 files changed, 648 insertions, 652 deletions
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index fd83d2b67..d71c62541 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -1,19 +1,19 @@
1/* 1/*
2 This file is part of GNUnet. 2 This file is part of GNUnet.
3 Copyright (C) 2009, 2010, 2011, 2012, 2013, 2016 GNUnet e.V. 3 Copyright (C) 2009, 2010, 2011, 2012, 2013, 2016 GNUnet e.V.
4 4
5 GNUnet is free software: you can redistribute it and/or modify it 5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published 6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License, 7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version. 8 or (at your option) any later version.
9 9
10 GNUnet is distributed in the hope that it will be useful, but 10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19 */ 19 */
@@ -76,7 +76,7 @@
76 GNUNET_MQ_PREF_CORK_ALLOWED) 76 GNUNET_MQ_PREF_CORK_ALLOWED)
77 77
78#if FREEBSD 78#if FREEBSD
79#define log2(a) (log (a) / log (2)) 79#define log2(a) (log(a) / log(2))
80#endif 80#endif
81 81
82/** 82/**
@@ -117,9 +117,7 @@ static struct GNUNET_BIO_WriteHandle *histogram;
117/** 117/**
118 * Per-peer information. 118 * Per-peer information.
119 */ 119 */
120struct NSEPeerEntry 120struct NSEPeerEntry {
121{
122
123 /** 121 /**
124 * Core handle for sending messages to this peer. 122 * Core handle for sending messages to this peer.
125 */ 123 */
@@ -143,7 +141,6 @@ struct NSEPeerEntry
143 int previous_round; 141 int previous_round;
144 142
145#if ENABLE_NSE_HISTOGRAM 143#if ENABLE_NSE_HISTOGRAM
146
147 /** 144 /**
148 * Amount of messages received from this peer on this round. 145 * Amount of messages received from this peer on this round.
149 */ 146 */
@@ -158,7 +155,6 @@ struct NSEPeerEntry
158 * Which size did we tell the peer the network is? 155 * Which size did we tell the peer the network is?
159 */ 156 */
160 unsigned int last_transmitted_size; 157 unsigned int last_transmitted_size;
161
162#endif 158#endif
163}; 159};
164 160
@@ -170,8 +166,7 @@ GNUNET_NETWORK_STRUCT_BEGIN
170 * peer's timer has run out before receiving a 166 * peer's timer has run out before receiving a
171 * valid reply from another peer. 167 * valid reply from another peer.
172 */ 168 */
173struct GNUNET_NSE_FloodMessage 169struct GNUNET_NSE_FloodMessage {
174{
175 /** 170 /**
176 * Type: #GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD 171 * Type: #GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD
177 */ 172 */
@@ -322,7 +317,7 @@ static uint64_t my_proof;
322 * @param em message to fill in 317 * @param em message to fill in
323 */ 318 */
324static void 319static void
325setup_estimate_message (struct GNUNET_NSE_ClientMessage *em) 320setup_estimate_message(struct GNUNET_NSE_ClientMessage *em)
326{ 321{
327 double mean; 322 double mean;
328 double sum; 323 double sum;
@@ -345,19 +340,19 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
345 sumweight = 0.0; 340 sumweight = 0.0;
346 variance = 0.0; 341 variance = 0.0;
347 for (unsigned int i = 0; i < estimate_count; i++) 342 for (unsigned int i = 0; i < estimate_count; i++)
348 { 343 {
349 unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE; 344 unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
350 345
351 val = htonl (size_estimate_messages[j].matching_bits); 346 val = htonl(size_estimate_messages[j].matching_bits);
352 weight = estimate_count + 1 - i; 347 weight = estimate_count + 1 - i;
353 348
354 temp = weight + sumweight; 349 temp = weight + sumweight;
355 q = val - mean; 350 q = val - mean;
356 r = q * weight / temp; 351 r = q * weight / temp;
357 mean += r; 352 mean += r;
358 sum += sumweight * q * r; 353 sum += sumweight * q * r;
359 sumweight = temp; 354 sumweight = temp;
360 } 355 }
361 if (estimate_count > 0) 356 if (estimate_count > 0)
362 variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0); 357 variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
363#else 358#else
@@ -371,44 +366,44 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
371 mean = 0.0; 366 mean = 0.0;
372 367
373 for (unsigned int i = 0; i < estimate_count; i++) 368 for (unsigned int i = 0; i < estimate_count; i++)
374 { 369 {
375 unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE; 370 unsigned int j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
376 371
377 val = htonl (size_estimate_messages[j].matching_bits); 372 val = htonl(size_estimate_messages[j].matching_bits);
378 sum += val; 373 sum += val;
379 vsq += val * val; 374 vsq += val * val;
380 } 375 }
381 if (0 != estimate_count) 376 if (0 != estimate_count)
382 { 377 {
383 mean = sum / estimate_count; 378 mean = sum / estimate_count;
384 variance = (vsq - mean * sum) / 379 variance = (vsq - mean * sum) /
385 (estimate_count - 1.0); // terrible for numerical stability... 380 (estimate_count - 1.0); // terrible for numerical stability...
386 } 381 }
387#endif 382#endif
388 if (variance >= 0) 383 if (variance >= 0)
389 std_dev = sqrt (variance); 384 std_dev = sqrt(variance);
390 else 385 else
391 std_dev = variance; /* must be infinity due to estimate_count == 0 */ 386 std_dev = variance; /* must be infinity due to estimate_count == 0 */
392 current_std_dev = std_dev; 387 current_std_dev = std_dev;
393 current_size_estimate = mean; 388 current_size_estimate = mean;
394 389
395 em->header.size = htons (sizeof (struct GNUNET_NSE_ClientMessage)); 390 em->header.size = htons(sizeof(struct GNUNET_NSE_ClientMessage));
396 em->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_ESTIMATE); 391 em->header.type = htons(GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
397 em->reserved = htonl (0); 392 em->reserved = htonl(0);
398 em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ()); 393 em->timestamp = GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get());
399 { 394 {
400 double se = mean - 0.332747; 395 double se = mean - 0.332747;
401 unsigned int j = GNUNET_CONTAINER_multipeermap_size (peers); 396 unsigned int j = GNUNET_CONTAINER_multipeermap_size(peers);
402 if (0 == j) 397 if (0 == j)
403 j = 1; /* Avoid log2(0); can only happen if CORE didn't report 398 j = 1; /* Avoid log2(0); can only happen if CORE didn't report
404 connection to self yet */ 399 connection to self yet */
405 nsize = log2 (j); 400 nsize = log2(j);
406 em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize)); 401 em->size_estimate = GNUNET_hton_double(GNUNET_MAX(se, nsize));
407 em->std_deviation = GNUNET_hton_double (std_dev); 402 em->std_deviation = GNUNET_hton_double(std_dev);
408 GNUNET_STATISTICS_set (stats, 403 GNUNET_STATISTICS_set(stats,
409 "# nodes in the network (estimate)", 404 "# nodes in the network (estimate)",
410 (uint64_t) pow (2, GNUNET_MAX (se, nsize)), 405 (uint64_t)pow(2, GNUNET_MAX(se, nsize)),
411 GNUNET_NO); 406 GNUNET_NO);
412 } 407 }
413} 408}
414 409
@@ -423,21 +418,21 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
423 * @param message the message received 418 * @param message the message received
424 */ 419 */
425static void 420static void
426handle_start (void *cls, const struct GNUNET_MessageHeader *message) 421handle_start(void *cls, const struct GNUNET_MessageHeader *message)
427{ 422{
428 struct GNUNET_SERVICE_Client *client = cls; 423 struct GNUNET_SERVICE_Client *client = cls;
429 struct GNUNET_MQ_Handle *mq; 424 struct GNUNET_MQ_Handle *mq;
430 struct GNUNET_NSE_ClientMessage em; 425 struct GNUNET_NSE_ClientMessage em;
431 struct GNUNET_MQ_Envelope *env; 426 struct GNUNET_MQ_Envelope *env;
432 427
433 (void) message; 428 (void)message;
434 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n"); 429 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
435 mq = GNUNET_SERVICE_client_get_mq (client); 430 mq = GNUNET_SERVICE_client_get_mq(client);
436 GNUNET_notification_context_add (nc, mq); 431 GNUNET_notification_context_add(nc, mq);
437 setup_estimate_message (&em); 432 setup_estimate_message(&em);
438 env = GNUNET_MQ_msg_copy (&em.header); 433 env = GNUNET_MQ_msg_copy(&em.header);
439 GNUNET_MQ_send (mq, env); 434 GNUNET_MQ_send(mq, env);
440 GNUNET_SERVICE_client_continue (client); 435 GNUNET_SERVICE_client_continue(client);
441} 436}
442 437
443 438
@@ -448,16 +443,16 @@ handle_start (void *cls, const struct GNUNET_MessageHeader *message)
448 * @param matching_bits number of matching bits to consider 443 * @param matching_bits number of matching bits to consider
449 */ 444 */
450static double 445static double
451get_matching_bits_delay (uint32_t matching_bits) 446get_matching_bits_delay(uint32_t matching_bits)
452{ 447{
453 /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */ 448 /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
454 // S is next_timestamp (ignored in return value) 449 // S is next_timestamp (ignored in return value)
455 // f is frequency (gnunet_nse_interval) 450 // f is frequency (gnunet_nse_interval)
456 // x is matching_bits 451 // x is matching_bits
457 // p' is current_size_estimate 452 // p' is current_size_estimate
458 return ((double) gnunet_nse_interval.rel_value_us / (double) 2.0) - 453 return ((double)gnunet_nse_interval.rel_value_us / (double)2.0) -
459 ((gnunet_nse_interval.rel_value_us / M_PI) * 454 ((gnunet_nse_interval.rel_value_us / M_PI) *
460 atan (matching_bits - current_size_estimate)); 455 atan(matching_bits - current_size_estimate));
461} 456}
462 457
463 458
@@ -468,21 +463,21 @@ get_matching_bits_delay (uint32_t matching_bits)
468 * @return random delay to apply 463 * @return random delay to apply
469 */ 464 */
470static struct GNUNET_TIME_Relative 465static struct GNUNET_TIME_Relative
471get_delay_randomization (uint32_t matching_bits) 466get_delay_randomization(uint32_t matching_bits)
472{ 467{
473#if USE_RANDOM_DELAYS 468#if USE_RANDOM_DELAYS
474 struct GNUNET_TIME_Relative ret; 469 struct GNUNET_TIME_Relative ret;
475 uint32_t i; 470 uint32_t i;
476 double d; 471 double d;
477 472
478 d = get_matching_bits_delay (matching_bits); 473 d = get_matching_bits_delay(matching_bits);
479 i = (uint32_t) (d / (double) (hop_count_max + 1)); 474 i = (uint32_t)(d / (double)(hop_count_max + 1));
480 ret.rel_value_us = i; 475 ret.rel_value_us = i;
481 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 476 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
482 "Randomizing flood using latencies up to %s\n", 477 "Randomizing flood using latencies up to %s\n",
483 GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); 478 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
484 ret.rel_value_us = 479 ret.rel_value_us =
485 GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1); 480 GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
486 return ret; 481 return ret;
487#else 482#else
488 return GNUNET_TIME_UNIT_ZERO; 483 return GNUNET_TIME_UNIT_ZERO;
@@ -498,18 +493,18 @@ get_delay_randomization (uint32_t matching_bits)
498 * @param result where to write the resulting hash 493 * @param result where to write the resulting hash
499 */ 494 */
500static void 495static void
501pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result) 496pow_hash(const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
502{ 497{
503 GNUNET_break ( 498 GNUNET_break(
504 0 == gcry_kdf_derive (buf, 499 0 == gcry_kdf_derive(buf,
505 buf_len, 500 buf_len,
506 GCRY_KDF_SCRYPT, 501 GCRY_KDF_SCRYPT,
507 1 /* subalgo */, 502 1 /* subalgo */,
508 "gnunet-proof-of-work", 503 "gnunet-proof-of-work",
509 strlen ("gnunet-proof-of-work"), 504 strlen("gnunet-proof-of-work"),
510 2 /* iterations; keep cost of individual op small */, 505 2 /* iterations; keep cost of individual op small */,
511 sizeof (struct GNUNET_HashCode), 506 sizeof(struct GNUNET_HashCode),
512 result)); 507 result));
513} 508}
514 509
515 510
@@ -521,17 +516,17 @@ pow_hash (const void *buf, size_t buf_len, struct GNUNET_HashCode *result)
521 * @return number of matching bits 516 * @return number of matching bits
522 */ 517 */
523static uint32_t 518static uint32_t
524get_matching_bits (struct GNUNET_TIME_Absolute timestamp, 519get_matching_bits(struct GNUNET_TIME_Absolute timestamp,
525 const struct GNUNET_PeerIdentity *id) 520 const struct GNUNET_PeerIdentity *id)
526{ 521{
527 struct GNUNET_HashCode timestamp_hash; 522 struct GNUNET_HashCode timestamp_hash;
528 struct GNUNET_HashCode pid_hash; 523 struct GNUNET_HashCode pid_hash;
529 524
530 GNUNET_CRYPTO_hash (&timestamp.abs_value_us, 525 GNUNET_CRYPTO_hash(&timestamp.abs_value_us,
531 sizeof (timestamp.abs_value_us), 526 sizeof(timestamp.abs_value_us),
532 &timestamp_hash); 527 &timestamp_hash);
533 GNUNET_CRYPTO_hash (id, sizeof (struct GNUNET_PeerIdentity), &pid_hash); 528 GNUNET_CRYPTO_hash(id, sizeof(struct GNUNET_PeerIdentity), &pid_hash);
534 return GNUNET_CRYPTO_hash_matching_bits (&timestamp_hash, &pid_hash); 529 return GNUNET_CRYPTO_hash_matching_bits(&timestamp_hash, &pid_hash);
535} 530}
536 531
537 532
@@ -544,7 +539,7 @@ get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
544 * @return delay that should be applied 539 * @return delay that should be applied
545 */ 540 */
546static struct GNUNET_TIME_Relative 541static struct GNUNET_TIME_Relative
547get_transmit_delay (int round_offset) 542get_transmit_delay(int round_offset)
548{ 543{
549 struct GNUNET_TIME_Relative ret; 544 struct GNUNET_TIME_Relative ret;
550 struct GNUNET_TIME_Absolute tgt; 545 struct GNUNET_TIME_Absolute tgt;
@@ -552,36 +547,37 @@ get_transmit_delay (int round_offset)
552 uint32_t matching_bits; 547 uint32_t matching_bits;
553 548
554 switch (round_offset) 549 switch (round_offset)
555 { 550 {
556 case -1: 551 case -1:
557 /* previous round is randomized between 0 and 50 ms */ 552 /* previous round is randomized between 0 and 50 ms */
558#if USE_RANDOM_DELAYS 553#if USE_RANDOM_DELAYS
559 ret.rel_value_us = 554 ret.rel_value_us =
560 GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50); 555 GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, 50);
561#else 556#else
562 ret = GNUNET_TIME_UNIT_ZERO; 557 ret = GNUNET_TIME_UNIT_ZERO;
563#endif 558#endif
564 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 559 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
565 "Transmitting previous round behind schedule in %s\n", 560 "Transmitting previous round behind schedule in %s\n",
566 GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); 561 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
567 return ret; 562 return ret;
568 case 0: 563
569 /* current round is based on best-known matching_bits */ 564 case 0:
570 matching_bits = 565 /* current round is based on best-known matching_bits */
571 ntohl (size_estimate_messages[estimate_index].matching_bits); 566 matching_bits =
572 dist_delay = get_matching_bits_delay (matching_bits); 567 ntohl(size_estimate_messages[estimate_index].matching_bits);
573 dist_delay += get_delay_randomization (matching_bits).rel_value_us; 568 dist_delay = get_matching_bits_delay(matching_bits);
574 ret.rel_value_us = (uint64_t) dist_delay; 569 dist_delay += get_delay_randomization(matching_bits).rel_value_us;
575 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 570 ret.rel_value_us = (uint64_t)dist_delay;
576 "For round %s, delay for %u matching bits is %s\n", 571 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
577 GNUNET_STRINGS_absolute_time_to_string (current_timestamp), 572 "For round %s, delay for %u matching bits is %s\n",
578 (unsigned int) matching_bits, 573 GNUNET_STRINGS_absolute_time_to_string(current_timestamp),
579 GNUNET_STRINGS_relative_time_to_string (ret, GNUNET_YES)); 574 (unsigned int)matching_bits,
580 /* now consider round start time and add delay to it */ 575 GNUNET_STRINGS_relative_time_to_string(ret, GNUNET_YES));
581 tgt = GNUNET_TIME_absolute_add (current_timestamp, ret); 576 /* now consider round start time and add delay to it */
582 return GNUNET_TIME_absolute_get_remaining (tgt); 577 tgt = GNUNET_TIME_absolute_add(current_timestamp, ret);
583 } 578 return GNUNET_TIME_absolute_get_remaining(tgt);
584 GNUNET_break (0); 579 }
580 GNUNET_break(0);
585 return GNUNET_TIME_UNIT_FOREVER_REL; 581 return GNUNET_TIME_UNIT_FOREVER_REL;
586} 582}
587 583
@@ -592,7 +588,7 @@ get_transmit_delay (int round_offset)
592 * @param cls the `struct NSEPeerEntry *` 588 * @param cls the `struct NSEPeerEntry *`
593 */ 589 */
594static void 590static void
595transmit_task_cb (void *cls) 591transmit_task_cb(void *cls)
596{ 592{
597 struct NSEPeerEntry *peer_entry = cls; 593 struct NSEPeerEntry *peer_entry = cls;
598 unsigned int idx; 594 unsigned int idx;
@@ -601,51 +597,51 @@ transmit_task_cb (void *cls)
601 peer_entry->transmit_task = NULL; 597 peer_entry->transmit_task = NULL;
602 idx = estimate_index; 598 idx = estimate_index;
603 if (GNUNET_NO == peer_entry->previous_round) 599 if (GNUNET_NO == peer_entry->previous_round)
604 { 600 {
605 idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE; 601 idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
606 peer_entry->previous_round = GNUNET_YES; 602 peer_entry->previous_round = GNUNET_YES;
607 peer_entry->transmit_task = 603 peer_entry->transmit_task =
608 GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0), 604 GNUNET_SCHEDULER_add_delayed(get_transmit_delay(0),
609 &transmit_task_cb, 605 &transmit_task_cb,
610 peer_entry); 606 peer_entry);
611 } 607 }
612 if ((0 == ntohl (size_estimate_messages[idx].hop_count)) && 608 if ((0 == ntohl(size_estimate_messages[idx].hop_count)) &&
613 (NULL != proof_task)) 609 (NULL != proof_task))
614 { 610 {
615 GNUNET_STATISTICS_update (stats, 611 GNUNET_STATISTICS_update(stats,
616 "# flood messages not generated (no proof yet)", 612 "# flood messages not generated (no proof yet)",
617 1, 613 1,
618 GNUNET_NO); 614 GNUNET_NO);
619 return; 615 return;
620 } 616 }
621 if (0 == ntohs (size_estimate_messages[idx].header.size)) 617 if (0 == ntohs(size_estimate_messages[idx].header.size))
622 { 618 {
623 GNUNET_STATISTICS_update (stats, 619 GNUNET_STATISTICS_update(stats,
624 "# flood messages not generated (lack of history)", 620 "# flood messages not generated (lack of history)",
625 1, 621 1,
626 GNUNET_NO); 622 GNUNET_NO);
627 return; 623 return;
628 } 624 }
629 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 625 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
630 "In round %s, sending to `%s' estimate with %u bits\n", 626 "In round %s, sending to `%s' estimate with %u bits\n",
631 GNUNET_STRINGS_absolute_time_to_string ( 627 GNUNET_STRINGS_absolute_time_to_string(
632 GNUNET_TIME_absolute_ntoh ( 628 GNUNET_TIME_absolute_ntoh(
633 size_estimate_messages[idx].timestamp)), 629 size_estimate_messages[idx].timestamp)),
634 GNUNET_i2s (peer_entry->id), 630 GNUNET_i2s(peer_entry->id),
635 (unsigned int) ntohl (size_estimate_messages[idx].matching_bits)); 631 (unsigned int)ntohl(size_estimate_messages[idx].matching_bits));
636 if (0 == ntohl (size_estimate_messages[idx].hop_count)) 632 if (0 == ntohl(size_estimate_messages[idx].hop_count))
637 GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO); 633 GNUNET_STATISTICS_update(stats, "# flood messages started", 1, GNUNET_NO);
638 GNUNET_STATISTICS_update (stats, 634 GNUNET_STATISTICS_update(stats,
639 "# flood messages transmitted", 635 "# flood messages transmitted",
640 1, 636 1,
641 GNUNET_NO); 637 GNUNET_NO);
642#if ENABLE_NSE_HISTOGRAM 638#if ENABLE_NSE_HISTOGRAM
643 peer_entry->transmitted_messages++; 639 peer_entry->transmitted_messages++;
644 peer_entry->last_transmitted_size = 640 peer_entry->last_transmitted_size =
645 ntohl (size_estimate_messages[idx].matching_bits); 641 ntohl(size_estimate_messages[idx].matching_bits);
646#endif 642#endif
647 env = GNUNET_MQ_msg_copy (&size_estimate_messages[idx].header); 643 env = GNUNET_MQ_msg_copy(&size_estimate_messages[idx].header);
648 GNUNET_MQ_send (peer_entry->mq, env); 644 GNUNET_MQ_send(peer_entry->mq, env);
649} 645}
650 646
651 647
@@ -656,12 +652,12 @@ transmit_task_cb (void *cls)
656 * clients. 652 * clients.
657 */ 653 */
658static void 654static void
659update_network_size_estimate () 655update_network_size_estimate()
660{ 656{
661 struct GNUNET_NSE_ClientMessage em; 657 struct GNUNET_NSE_ClientMessage em;
662 658
663 setup_estimate_message (&em); 659 setup_estimate_message(&em);
664 GNUNET_notification_context_broadcast (nc, &em.header, GNUNET_YES); 660 GNUNET_notification_context_broadcast(nc, &em.header, GNUNET_YES);
665} 661}
666 662
667 663
@@ -673,31 +669,31 @@ update_network_size_estimate ()
673 * @param ts timestamp to use 669 * @param ts timestamp to use
674 */ 670 */
675static void 671static void
676setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts) 672setup_flood_message(unsigned int slot, struct GNUNET_TIME_Absolute ts)
677{ 673{
678 struct GNUNET_NSE_FloodMessage *fm; 674 struct GNUNET_NSE_FloodMessage *fm;
679 uint32_t matching_bits; 675 uint32_t matching_bits;
680 676
681 matching_bits = get_matching_bits (ts, &my_identity); 677 matching_bits = get_matching_bits(ts, &my_identity);
682 fm = &size_estimate_messages[slot]; 678 fm = &size_estimate_messages[slot];
683 fm->header.size = htons (sizeof (struct GNUNET_NSE_FloodMessage)); 679 fm->header.size = htons(sizeof(struct GNUNET_NSE_FloodMessage));
684 fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD); 680 fm->header.type = htons(GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
685 fm->hop_count = htonl (0); 681 fm->hop_count = htonl(0);
686 fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND); 682 fm->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
687 fm->purpose.size = 683 fm->purpose.size =
688 htonl (sizeof (struct GNUNET_NSE_FloodMessage) - 684 htonl(sizeof(struct GNUNET_NSE_FloodMessage) -
689 sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) - 685 sizeof(struct GNUNET_MessageHeader) - sizeof(uint32_t) -
690 sizeof (struct GNUNET_CRYPTO_EddsaSignature)); 686 sizeof(struct GNUNET_CRYPTO_EddsaSignature));
691 fm->matching_bits = htonl (matching_bits); 687 fm->matching_bits = htonl(matching_bits);
692 fm->timestamp = GNUNET_TIME_absolute_hton (ts); 688 fm->timestamp = GNUNET_TIME_absolute_hton(ts);
693 fm->origin = my_identity; 689 fm->origin = my_identity;
694 fm->proof_of_work = my_proof; 690 fm->proof_of_work = my_proof;
695 if (nse_work_required > 0) 691 if (nse_work_required > 0)
696 GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, 692 GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
697 &fm->purpose, 693 &fm->purpose,
698 &fm->signature)); 694 &fm->signature));
699 else 695 else
700 memset (&fm->signature, 0, sizeof (fm->signature)); 696 memset(&fm->signature, 0, sizeof(fm->signature));
701} 697}
702 698
703 699
@@ -711,34 +707,34 @@ setup_flood_message (unsigned int slot, struct GNUNET_TIME_Absolute ts)
711 * @return #GNUNET_OK (continue to iterate) 707 * @return #GNUNET_OK (continue to iterate)
712 */ 708 */
713static int 709static int
714schedule_current_round (void *cls, 710schedule_current_round(void *cls,
715 const struct GNUNET_PeerIdentity *key, 711 const struct GNUNET_PeerIdentity *key,
716 void *value) 712 void *value)
717{ 713{
718 struct NSEPeerEntry *peer_entry = value; 714 struct NSEPeerEntry *peer_entry = value;
719 struct GNUNET_TIME_Relative delay; 715 struct GNUNET_TIME_Relative delay;
720 716
721 (void) cls; 717 (void)cls;
722 (void) key; 718 (void)key;
723 if (NULL != peer_entry->transmit_task) 719 if (NULL != peer_entry->transmit_task)
724 { 720 {
725 GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); 721 GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
726 peer_entry->previous_round = GNUNET_NO; 722 peer_entry->previous_round = GNUNET_NO;
727 } 723 }
728#if ENABLE_NSE_HISTOGRAM 724#if ENABLE_NSE_HISTOGRAM
729 if (peer_entry->received_messages > 1) 725 if (peer_entry->received_messages > 1)
730 GNUNET_STATISTICS_update (stats, 726 GNUNET_STATISTICS_update(stats,
731 "# extra messages", 727 "# extra messages",
732 peer_entry->received_messages - 1, 728 peer_entry->received_messages - 1,
733 GNUNET_NO); 729 GNUNET_NO);
734 peer_entry->transmitted_messages = 0; 730 peer_entry->transmitted_messages = 0;
735 peer_entry->last_transmitted_size = 0; 731 peer_entry->last_transmitted_size = 0;
736 peer_entry->received_messages = 0; 732 peer_entry->received_messages = 0;
737#endif 733#endif
738 delay = 734 delay =
739 get_transmit_delay ((GNUNET_NO == peer_entry->previous_round) ? -1 : 0); 735 get_transmit_delay((GNUNET_NO == peer_entry->previous_round) ? -1 : 0);
740 peer_entry->transmit_task = 736 peer_entry->transmit_task =
741 GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry); 737 GNUNET_SCHEDULER_add_delayed(delay, &transmit_task_cb, peer_entry);
742 return GNUNET_OK; 738 return GNUNET_OK;
743} 739}
744 740
@@ -749,46 +745,46 @@ schedule_current_round (void *cls,
749 * @param cls unused 745 * @param cls unused
750 */ 746 */
751static void 747static void
752update_flood_message (void *cls) 748update_flood_message(void *cls)
753{ 749{
754 struct GNUNET_TIME_Relative offset; 750 struct GNUNET_TIME_Relative offset;
755 751
756 (void) cls; 752 (void)cls;
757 flood_task = NULL; 753 flood_task = NULL;
758 offset = GNUNET_TIME_absolute_get_remaining (next_timestamp); 754 offset = GNUNET_TIME_absolute_get_remaining(next_timestamp);
759 if (0 != offset.rel_value_us) 755 if (0 != offset.rel_value_us)
760 { 756 {
761 /* somehow run early, delay more */ 757 /* somehow run early, delay more */
762 flood_task = 758 flood_task =
763 GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL); 759 GNUNET_SCHEDULER_add_delayed(offset, &update_flood_message, NULL);
764 return; 760 return;
765 } 761 }
766 estimate_index = (estimate_index + 1) % HISTORY_SIZE; 762 estimate_index = (estimate_index + 1) % HISTORY_SIZE;
767 if (estimate_count < HISTORY_SIZE) 763 if (estimate_count < HISTORY_SIZE)
768 estimate_count++; 764 estimate_count++;
769 current_timestamp = next_timestamp; 765 current_timestamp = next_timestamp;
770 next_timestamp = 766 next_timestamp =
771 GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval); 767 GNUNET_TIME_absolute_add(current_timestamp, gnunet_nse_interval);
772 if ((current_timestamp.abs_value_us == 768 if ((current_timestamp.abs_value_us ==
773 GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value_us) && 769 GNUNET_TIME_absolute_ntoh(next_message.timestamp).abs_value_us) &&
774 (get_matching_bits (current_timestamp, &my_identity) < 770 (get_matching_bits(current_timestamp, &my_identity) <
775 ntohl (next_message.matching_bits))) 771 ntohl(next_message.matching_bits)))
776 { 772 {
777 /* we received a message for this round way early, use it! */ 773 /* we received a message for this round way early, use it! */
778 size_estimate_messages[estimate_index] = next_message; 774 size_estimate_messages[estimate_index] = next_message;
779 size_estimate_messages[estimate_index].hop_count = 775 size_estimate_messages[estimate_index].hop_count =
780 htonl (1 + ntohl (next_message.hop_count)); 776 htonl(1 + ntohl(next_message.hop_count));
781 } 777 }
782 else 778 else
783 setup_flood_message (estimate_index, current_timestamp); 779 setup_flood_message(estimate_index, current_timestamp);
784 next_message.matching_bits = htonl (0); /* reset for 'next' round */ 780 next_message.matching_bits = htonl(0); /* reset for 'next' round */
785 hop_count_max = 0; 781 hop_count_max = 0;
786 for (unsigned int i = 0; i < HISTORY_SIZE; i++) 782 for (unsigned int i = 0; i < HISTORY_SIZE; i++)
787 hop_count_max = 783 hop_count_max =
788 GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max); 784 GNUNET_MAX(ntohl(size_estimate_messages[i].hop_count), hop_count_max);
789 GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL); 785 GNUNET_CONTAINER_multipeermap_iterate(peers, &schedule_current_round, NULL);
790 flood_task = 786 flood_task =
791 GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL); 787 GNUNET_SCHEDULER_add_at(next_timestamp, &update_flood_message, NULL);
792} 788}
793 789
794 790
@@ -799,12 +795,12 @@ update_flood_message (void *cls)
799 * @return the number of leading zero bits. 795 * @return the number of leading zero bits.
800 */ 796 */
801static unsigned int 797static unsigned int
802count_leading_zeroes (const struct GNUNET_HashCode *hash) 798count_leading_zeroes(const struct GNUNET_HashCode *hash)
803{ 799{
804 unsigned int hash_count; 800 unsigned int hash_count;
805 801
806 hash_count = 0; 802 hash_count = 0;
807 while (0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count)) 803 while (0 == GNUNET_CRYPTO_hash_get_bit(hash, hash_count))
808 hash_count++; 804 hash_count++;
809 return hash_count; 805 return hash_count;
810} 806}
@@ -819,20 +815,20 @@ count_leading_zeroes (const struct GNUNET_HashCode *hash)
819 * @return #GNUNET_YES if valid, #GNUNET_NO if not 815 * @return #GNUNET_YES if valid, #GNUNET_NO if not
820 */ 816 */
821static int 817static int
822check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey, 818check_proof_of_work(const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
823 uint64_t val) 819 uint64_t val)
824{ 820{
825 char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) + 821 char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
826 sizeof (val)] GNUNET_ALIGN; 822 sizeof(val)] GNUNET_ALIGN;
827 struct GNUNET_HashCode result; 823 struct GNUNET_HashCode result;
828 824
829 GNUNET_memcpy (buf, &val, sizeof (val)); 825 GNUNET_memcpy(buf, &val, sizeof(val));
830 GNUNET_memcpy (&buf[sizeof (val)], 826 GNUNET_memcpy(&buf[sizeof(val)],
831 pkey, 827 pkey,
832 sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); 828 sizeof(struct GNUNET_CRYPTO_EddsaPublicKey));
833 pow_hash (buf, sizeof (buf), &result); 829 pow_hash(buf, sizeof(buf), &result);
834 return (count_leading_zeroes (&result) >= nse_work_required) ? GNUNET_YES 830 return (count_leading_zeroes(&result) >= nse_work_required) ? GNUNET_YES
835 : GNUNET_NO; 831 : GNUNET_NO;
836} 832}
837 833
838 834
@@ -840,20 +836,20 @@ check_proof_of_work (const struct GNUNET_CRYPTO_EddsaPublicKey *pkey,
840 * Write our current proof to disk. 836 * Write our current proof to disk.
841 */ 837 */
842static void 838static void
843write_proof () 839write_proof()
844{ 840{
845 char *proof; 841 char *proof;
846 842
847 if (GNUNET_OK != 843 if (GNUNET_OK !=
848 GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof)) 844 GNUNET_CONFIGURATION_get_value_filename(cfg, "NSE", "PROOFFILE", &proof))
849 return; 845 return;
850 if (sizeof (my_proof) != GNUNET_DISK_fn_write (proof, 846 if (sizeof(my_proof) != GNUNET_DISK_fn_write(proof,
851 &my_proof, 847 &my_proof,
852 sizeof (my_proof), 848 sizeof(my_proof),
853 GNUNET_DISK_PERM_USER_READ | 849 GNUNET_DISK_PERM_USER_READ |
854 GNUNET_DISK_PERM_USER_WRITE)) 850 GNUNET_DISK_PERM_USER_WRITE))
855 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof); 851 GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "write", proof);
856 GNUNET_free (proof); 852 GNUNET_free(proof);
857} 853}
858 854
859 855
@@ -863,57 +859,57 @@ write_proof ()
863 * @param cls closure (unused) 859 * @param cls closure (unused)
864 */ 860 */
865static void 861static void
866find_proof (void *cls) 862find_proof(void *cls)
867{ 863{
868#define ROUND_SIZE 10 864#define ROUND_SIZE 10
869 uint64_t counter; 865 uint64_t counter;
870 char buf[sizeof (struct GNUNET_CRYPTO_EddsaPublicKey) + 866 char buf[sizeof(struct GNUNET_CRYPTO_EddsaPublicKey) +
871 sizeof (uint64_t)] GNUNET_ALIGN; 867 sizeof(uint64_t)] GNUNET_ALIGN;
872 struct GNUNET_HashCode result; 868 struct GNUNET_HashCode result;
873 unsigned int i; 869 unsigned int i;
874 870
875 (void) cls; 871 (void)cls;
876 proof_task = NULL; 872 proof_task = NULL;
877 GNUNET_memcpy (&buf[sizeof (uint64_t)], 873 GNUNET_memcpy(&buf[sizeof(uint64_t)],
878 &my_identity, 874 &my_identity,
879 sizeof (struct GNUNET_PeerIdentity)); 875 sizeof(struct GNUNET_PeerIdentity));
880 i = 0; 876 i = 0;
881 counter = my_proof; 877 counter = my_proof;
882 while ((counter != UINT64_MAX) && (i < ROUND_SIZE)) 878 while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
883 {
884 GNUNET_memcpy (buf, &counter, sizeof (uint64_t));
885 pow_hash (buf, sizeof (buf), &result);
886 if (nse_work_required <= count_leading_zeroes (&result))
887 { 879 {
888 my_proof = counter; 880 GNUNET_memcpy(buf, &counter, sizeof(uint64_t));
889 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 881 pow_hash(buf, sizeof(buf), &result);
890 "Proof of work found: %llu!\n", 882 if (nse_work_required <= count_leading_zeroes(&result))
891 (unsigned long long) GNUNET_ntohll (counter)); 883 {
892 write_proof (); 884 my_proof = counter;
893 setup_flood_message (estimate_index, current_timestamp); 885 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
894 return; 886 "Proof of work found: %llu!\n",
887 (unsigned long long)GNUNET_ntohll(counter));
888 write_proof();
889 setup_flood_message(estimate_index, current_timestamp);
890 return;
891 }
892 counter++;
893 i++;
895 } 894 }
896 counter++;
897 i++;
898 }
899 if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE)) 895 if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
900 { 896 {
901 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 897 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
902 "Testing proofs currently at %llu\n", 898 "Testing proofs currently at %llu\n",
903 (unsigned long long) counter); 899 (unsigned long long)counter);
904 /* remember progress every 100 rounds */ 900 /* remember progress every 100 rounds */
905 my_proof = counter; 901 my_proof = counter;
906 write_proof (); 902 write_proof();
907 } 903 }
908 else 904 else
909 { 905 {
910 my_proof = counter; 906 my_proof = counter;
911 } 907 }
912 proof_task = 908 proof_task =
913 GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay, 909 GNUNET_SCHEDULER_add_delayed_with_priority(proof_find_delay,
914 GNUNET_SCHEDULER_PRIORITY_IDLE, 910 GNUNET_SCHEDULER_PRIORITY_IDLE,
915 &find_proof, 911 &find_proof,
916 NULL); 912 NULL);
917} 913}
918 914
919 915
@@ -927,28 +923,28 @@ find_proof (void *cls)
927 * #GNUNET_NO if the key/signature don't verify 923 * #GNUNET_NO if the key/signature don't verify
928 */ 924 */
929static int 925static int
930verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood) 926verify_message_crypto(const struct GNUNET_NSE_FloodMessage *incoming_flood)
931{ 927{
932 if (GNUNET_YES != check_proof_of_work (&incoming_flood->origin.public_key, 928 if (GNUNET_YES != check_proof_of_work(&incoming_flood->origin.public_key,
933 incoming_flood->proof_of_work)) 929 incoming_flood->proof_of_work))
934 { 930 {
935 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 931 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
936 "Proof of work invalid: %llu!\n", 932 "Proof of work invalid: %llu!\n",
937 (unsigned long long) GNUNET_ntohll ( 933 (unsigned long long)GNUNET_ntohll(
938 incoming_flood->proof_of_work)); 934 incoming_flood->proof_of_work));
939 GNUNET_break_op (0); 935 GNUNET_break_op(0);
940 return GNUNET_NO; 936 return GNUNET_NO;
941 } 937 }
942 if ((nse_work_required > 0) && 938 if ((nse_work_required > 0) &&
943 (GNUNET_OK != 939 (GNUNET_OK !=
944 GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND, 940 GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
945 &incoming_flood->purpose, 941 &incoming_flood->purpose,
946 &incoming_flood->signature, 942 &incoming_flood->signature,
947 &incoming_flood->origin.public_key))) 943 &incoming_flood->origin.public_key)))
948 { 944 {
949 GNUNET_break_op (0); 945 GNUNET_break_op(0);
950 return GNUNET_NO; 946 return GNUNET_NO;
951 } 947 }
952 return GNUNET_YES; 948 return GNUNET_YES;
953} 949}
954 950
@@ -963,35 +959,35 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
963 * @return #GNUNET_OK (continue to iterate) 959 * @return #GNUNET_OK (continue to iterate)
964 */ 960 */
965static int 961static int
966update_flood_times (void *cls, 962update_flood_times(void *cls,
967 const struct GNUNET_PeerIdentity *key, 963 const struct GNUNET_PeerIdentity *key,
968 void *value) 964 void *value)
969{ 965{
970 struct NSEPeerEntry *exclude = cls; 966 struct NSEPeerEntry *exclude = cls;
971 struct NSEPeerEntry *peer_entry = value; 967 struct NSEPeerEntry *peer_entry = value;
972 struct GNUNET_TIME_Relative delay; 968 struct GNUNET_TIME_Relative delay;
973 969
974 (void) key; 970 (void)key;
975 if (peer_entry == exclude) 971 if (peer_entry == exclude)
976 return GNUNET_OK; /* trigger of the update */ 972 return GNUNET_OK; /* trigger of the update */
977 if (GNUNET_NO == peer_entry->previous_round) 973 if (GNUNET_NO == peer_entry->previous_round)
978 {
979 /* still stuck in previous round, no point to update, check that
980 * we are active here though... */
981 if (NULL == peer_entry->transmit_task)
982 { 974 {
983 GNUNET_break (0); 975 /* still stuck in previous round, no point to update, check that
976 * we are active here though... */
977 if (NULL == peer_entry->transmit_task)
978 {
979 GNUNET_break(0);
980 }
981 return GNUNET_OK;
984 } 982 }
985 return GNUNET_OK;
986 }
987 if (NULL != peer_entry->transmit_task) 983 if (NULL != peer_entry->transmit_task)
988 { 984 {
989 GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); 985 GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
990 peer_entry->transmit_task = NULL; 986 peer_entry->transmit_task = NULL;
991 } 987 }
992 delay = get_transmit_delay (0); 988 delay = get_transmit_delay(0);
993 peer_entry->transmit_task = 989 peer_entry->transmit_task =
994 GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry); 990 GNUNET_SCHEDULER_add_delayed(delay, &transmit_task_cb, peer_entry);
995 return GNUNET_OK; 991 return GNUNET_OK;
996} 992}
997 993
@@ -1003,8 +999,8 @@ update_flood_times (void *cls,
1003 * @param incoming_flood received message 999 * @param incoming_flood received message
1004 */ 1000 */
1005static void 1001static void
1006handle_p2p_estimate (void *cls, 1002handle_p2p_estimate(void *cls,
1007 const struct GNUNET_NSE_FloodMessage *incoming_flood) 1003 const struct GNUNET_NSE_FloodMessage *incoming_flood)
1008{ 1004{
1009 struct NSEPeerEntry *peer_entry = cls; 1005 struct NSEPeerEntry *peer_entry = cls;
1010 struct GNUNET_TIME_Absolute ts; 1006 struct GNUNET_TIME_Absolute ts;
@@ -1015,34 +1011,34 @@ handle_p2p_estimate (void *cls,
1015 { 1011 {
1016 uint64_t t; 1012 uint64_t t;
1017 1013
1018 t = GNUNET_TIME_absolute_get ().abs_value_us; 1014 t = GNUNET_TIME_absolute_get().abs_value_us;
1019 if (NULL != lh) 1015 if (NULL != lh)
1020 GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t)); 1016 GNUNET_TESTBED_LOGGER_write(lh, &t, sizeof(uint64_t));
1021 if (NULL != histogram) 1017 if (NULL != histogram)
1022 GNUNET_BIO_write_int64 (histogram, t); 1018 GNUNET_BIO_write_int64(histogram, t);
1023 } 1019 }
1024#endif 1020#endif
1025 GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO); 1021 GNUNET_STATISTICS_update(stats, "# flood messages received", 1, GNUNET_NO);
1026 matching_bits = ntohl (incoming_flood->matching_bits); 1022 matching_bits = ntohl(incoming_flood->matching_bits);
1027#if DEBUG_NSE 1023#if DEBUG_NSE
1028 { 1024 {
1029 char origin[5]; 1025 char origin[5];
1030 char pred[5]; 1026 char pred[5];
1031 struct GNUNET_PeerIdentity os; 1027 struct GNUNET_PeerIdentity os;
1032 1028
1033 GNUNET_snprintf (origin, 1029 GNUNET_snprintf(origin,
1034 sizeof (origin), 1030 sizeof(origin),
1035 "%s", 1031 "%s",
1036 GNUNET_i2s (&incoming_flood->origin)); 1032 GNUNET_i2s(&incoming_flood->origin));
1037 GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer_entry->id)); 1033 GNUNET_snprintf(pred, sizeof(pred), "%s", GNUNET_i2s(peer_entry->id));
1038 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 1034 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1039 "Flood at %s from `%s' via `%s' at `%s' with bits %u\n", 1035 "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
1040 GNUNET_STRINGS_absolute_time_to_string ( 1036 GNUNET_STRINGS_absolute_time_to_string(
1041 GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)), 1037 GNUNET_TIME_absolute_ntoh(incoming_flood->timestamp)),
1042 origin, 1038 origin,
1043 pred, 1039 pred,
1044 GNUNET_i2s (&my_identity), 1040 GNUNET_i2s(&my_identity),
1045 (unsigned int) matching_bits); 1041 (unsigned int)matching_bits);
1046 } 1042 }
1047#endif 1043#endif
1048 1044
@@ -1050,122 +1046,122 @@ handle_p2p_estimate (void *cls,
1050 peer_entry->received_messages++; 1046 peer_entry->received_messages++;
1051 if (peer_entry->transmitted_messages > 0 && 1047 if (peer_entry->transmitted_messages > 0 &&
1052 peer_entry->last_transmitted_size >= matching_bits) 1048 peer_entry->last_transmitted_size >= matching_bits)
1053 GNUNET_STATISTICS_update (stats, "# cross messages", 1, GNUNET_NO); 1049 GNUNET_STATISTICS_update(stats, "# cross messages", 1, GNUNET_NO);
1054#endif 1050#endif
1055 1051
1056 ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp); 1052 ts = GNUNET_TIME_absolute_ntoh(incoming_flood->timestamp);
1057 if (ts.abs_value_us == current_timestamp.abs_value_us) 1053 if (ts.abs_value_us == current_timestamp.abs_value_us)
1058 idx = estimate_index; 1054 idx = estimate_index;
1059 else if (ts.abs_value_us == 1055 else if (ts.abs_value_us ==
1060 current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us) 1056 current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us)
1061 idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE; 1057 idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
1062 else if (ts.abs_value_us == next_timestamp.abs_value_us) 1058 else if (ts.abs_value_us == next_timestamp.abs_value_us)
1063 {
1064 if (matching_bits <= ntohl (next_message.matching_bits))
1065 return; /* ignore, simply too early/late */
1066 if (GNUNET_YES != verify_message_crypto (incoming_flood))
1067 { 1059 {
1068 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 1060 if (matching_bits <= ntohl(next_message.matching_bits))
1069 "Peer %s is likely ill-configured!\n", 1061 return; /* ignore, simply too early/late */
1070 GNUNET_i2s (peer_entry->id)); 1062 if (GNUNET_YES != verify_message_crypto(incoming_flood))
1071 GNUNET_break_op (0); 1063 {
1064 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
1065 "Peer %s is likely ill-configured!\n",
1066 GNUNET_i2s(peer_entry->id));
1067 GNUNET_break_op(0);
1068 return;
1069 }
1070 next_message = *incoming_flood;
1072 return; 1071 return;
1073 } 1072 }
1074 next_message = *incoming_flood;
1075 return;
1076 }
1077 else 1073 else
1078 {
1079 GNUNET_STATISTICS_update (stats,
1080 "# flood messages discarded (clock skew too large)",
1081 1,
1082 GNUNET_NO);
1083 return;
1084 }
1085 if (0 == (GNUNET_memcmp (peer_entry->id, &my_identity)))
1086 {
1087 /* send to self, update our own estimate IF this also comes from us! */
1088 if (0 == GNUNET_memcmp (&incoming_flood->origin, &my_identity))
1089 update_network_size_estimate ();
1090 return;
1091 }
1092 if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
1093 {
1094 /* Cancel transmission in the other direction, as this peer clearly has
1095 up-to-date information already. Even if we didn't talk to this peer in
1096 the previous round, we should no longer send it stale information as it
1097 told us about the current round! */
1098 peer_entry->previous_round = GNUNET_YES;
1099 if (idx != estimate_index)
1100 { 1074 {
1101 /* do not transmit information for the previous round to this peer 1075 GNUNET_STATISTICS_update(stats,
1102 anymore (but allow current round) */ 1076 "# flood messages discarded (clock skew too large)",
1077 1,
1078 GNUNET_NO);
1103 return; 1079 return;
1104 } 1080 }
1105 /* got up-to-date information for current round, cancel transmission to 1081 if (0 == (GNUNET_memcmp(peer_entry->id, &my_identity)))
1106 * this peer altogether */
1107 if (NULL != peer_entry->transmit_task)
1108 { 1082 {
1109 GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); 1083 /* send to self, update our own estimate IF this also comes from us! */
1110 peer_entry->transmit_task = NULL; 1084 if (0 == GNUNET_memcmp(&incoming_flood->origin, &my_identity))
1085 update_network_size_estimate();
1086 return;
1111 } 1087 }
1112 return; 1088 if (matching_bits == ntohl(size_estimate_messages[idx].matching_bits))
1113 }
1114 if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
1115 {
1116 if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
1117 { 1089 {
1118 peer_entry->previous_round = GNUNET_NO; 1090 /* Cancel transmission in the other direction, as this peer clearly has
1091 up-to-date information already. Even if we didn't talk to this peer in
1092 the previous round, we should no longer send it stale information as it
1093 told us about the current round! */
1094 peer_entry->previous_round = GNUNET_YES;
1095 if (idx != estimate_index)
1096 {
1097 /* do not transmit information for the previous round to this peer
1098 anymore (but allow current round) */
1099 return;
1100 }
1101 /* got up-to-date information for current round, cancel transmission to
1102 * this peer altogether */
1103 if (NULL != peer_entry->transmit_task)
1104 {
1105 GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
1106 peer_entry->transmit_task = NULL;
1107 }
1108 return;
1119 } 1109 }
1120 /* push back our result now, that peer is spreading bad information... */ 1110 if (matching_bits < ntohl(size_estimate_messages[idx].matching_bits))
1121 if (NULL != peer_entry->transmit_task) 1111 {
1122 GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); 1112 if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES))
1123 peer_entry->transmit_task = 1113 {
1124 GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry); 1114 peer_entry->previous_round = GNUNET_NO;
1125 /* Not closer than our most recent message, no need to do work here */ 1115 }
1126 GNUNET_STATISTICS_update (stats, 1116 /* push back our result now, that peer is spreading bad information... */
1127 "# flood messages ignored (had closer already)", 1117 if (NULL != peer_entry->transmit_task)
1128 1, 1118 GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
1129 GNUNET_NO); 1119 peer_entry->transmit_task =
1130 return; 1120 GNUNET_SCHEDULER_add_now(&transmit_task_cb, peer_entry);
1131 } 1121 /* Not closer than our most recent message, no need to do work here */
1132 if (GNUNET_YES != verify_message_crypto (incoming_flood)) 1122 GNUNET_STATISTICS_update(stats,
1133 { 1123 "# flood messages ignored (had closer already)",
1134 GNUNET_break_op (0); 1124 1,
1135 return; 1125 GNUNET_NO);
1136 } 1126 return;
1137 GNUNET_assert (matching_bits > 1127 }
1138 ntohl (size_estimate_messages[idx].matching_bits)); 1128 if (GNUNET_YES != verify_message_crypto(incoming_flood))
1129 {
1130 GNUNET_break_op(0);
1131 return;
1132 }
1133 GNUNET_assert(matching_bits >
1134 ntohl(size_estimate_messages[idx].matching_bits));
1139 /* Cancel transmission in the other direction, as this peer clearly has 1135 /* Cancel transmission in the other direction, as this peer clearly has
1140 * up-to-date information already. 1136 * up-to-date information already.
1141 */ 1137 */
1142 peer_entry->previous_round = GNUNET_YES; 1138 peer_entry->previous_round = GNUNET_YES;
1143 if (idx == estimate_index) 1139 if (idx == estimate_index)
1144 {
1145 /* cancel any activity for current round */
1146 if (NULL != peer_entry->transmit_task)
1147 { 1140 {
1148 GNUNET_SCHEDULER_cancel (peer_entry->transmit_task); 1141 /* cancel any activity for current round */
1149 peer_entry->transmit_task = NULL; 1142 if (NULL != peer_entry->transmit_task)
1143 {
1144 GNUNET_SCHEDULER_cancel(peer_entry->transmit_task);
1145 peer_entry->transmit_task = NULL;
1146 }
1150 } 1147 }
1151 }
1152 size_estimate_messages[idx] = *incoming_flood; 1148 size_estimate_messages[idx] = *incoming_flood;
1153 size_estimate_messages[idx].hop_count = 1149 size_estimate_messages[idx].hop_count =
1154 htonl (ntohl (incoming_flood->hop_count) + 1); 1150 htonl(ntohl(incoming_flood->hop_count) + 1);
1155 hop_count_max = 1151 hop_count_max =
1156 GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max); 1152 GNUNET_MAX(ntohl(incoming_flood->hop_count) + 1, hop_count_max);
1157 GNUNET_STATISTICS_set (stats, 1153 GNUNET_STATISTICS_set(stats,
1158 "# estimated network diameter", 1154 "# estimated network diameter",
1159 hop_count_max, 1155 hop_count_max,
1160 GNUNET_NO); 1156 GNUNET_NO);
1161 1157
1162 /* have a new, better size estimate, inform clients */ 1158 /* have a new, better size estimate, inform clients */
1163 update_network_size_estimate (); 1159 update_network_size_estimate();
1164 1160
1165 /* flood to rest */ 1161 /* flood to rest */
1166 GNUNET_CONTAINER_multipeermap_iterate (peers, 1162 GNUNET_CONTAINER_multipeermap_iterate(peers,
1167 &update_flood_times, 1163 &update_flood_times,
1168 peer_entry); 1164 peer_entry);
1169} 1165}
1170 1166
1171 1167
@@ -1177,33 +1173,33 @@ handle_p2p_estimate (void *cls,
1177 * @param peer peer identity this notification is about 1173 * @param peer peer identity this notification is about
1178 */ 1174 */
1179static void * 1175static void *
1180handle_core_connect (void *cls, 1176handle_core_connect(void *cls,
1181 const struct GNUNET_PeerIdentity *peer, 1177 const struct GNUNET_PeerIdentity *peer,
1182 struct GNUNET_MQ_Handle *mq) 1178 struct GNUNET_MQ_Handle *mq)
1183{ 1179{
1184 struct NSEPeerEntry *peer_entry; 1180 struct NSEPeerEntry *peer_entry;
1185 1181
1186 (void) cls; 1182 (void)cls;
1187 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 1183 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1188 "Peer `%s' connected to us\n", 1184 "Peer `%s' connected to us\n",
1189 GNUNET_i2s (peer)); 1185 GNUNET_i2s(peer));
1190 /* set our default transmission options */ 1186 /* set our default transmission options */
1191 GNUNET_MQ_set_options (mq, NSE_PRIORITY); 1187 GNUNET_MQ_set_options(mq, NSE_PRIORITY);
1192 /* create our peer entry for this peer */ 1188 /* create our peer entry for this peer */
1193 peer_entry = GNUNET_new (struct NSEPeerEntry); 1189 peer_entry = GNUNET_new(struct NSEPeerEntry);
1194 peer_entry->id = peer; 1190 peer_entry->id = peer;
1195 peer_entry->mq = mq; 1191 peer_entry->mq = mq;
1196 GNUNET_assert (GNUNET_OK == 1192 GNUNET_assert(GNUNET_OK ==
1197 GNUNET_CONTAINER_multipeermap_put ( 1193 GNUNET_CONTAINER_multipeermap_put(
1198 peers, 1194 peers,
1199 peer_entry->id, 1195 peer_entry->id,
1200 peer_entry, 1196 peer_entry,
1201 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); 1197 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1202 peer_entry->transmit_task = 1198 peer_entry->transmit_task =
1203 GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1), 1199 GNUNET_SCHEDULER_add_delayed(get_transmit_delay(-1),
1204 &transmit_task_cb, 1200 &transmit_task_cb,
1205 peer_entry); 1201 peer_entry);
1206 GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO); 1202 GNUNET_STATISTICS_update(stats, "# peers connected", 1, GNUNET_NO);
1207 return peer_entry; 1203 return peer_entry;
1208} 1204}
1209 1205
@@ -1217,25 +1213,25 @@ handle_core_connect (void *cls,
1217 * @parma internal_cls the `struct NSEPeerEntry` for the @a peer 1213 * @parma internal_cls the `struct NSEPeerEntry` for the @a peer
1218 */ 1214 */
1219static void 1215static void
1220handle_core_disconnect (void *cls, 1216handle_core_disconnect(void *cls,
1221 const struct GNUNET_PeerIdentity *peer, 1217 const struct GNUNET_PeerIdentity *peer,
1222 void *internal_cls) 1218 void *internal_cls)
1223{ 1219{
1224 struct NSEPeerEntry *pos = internal_cls; 1220 struct NSEPeerEntry *pos = internal_cls;
1225 1221
1226 (void) cls; 1222 (void)cls;
1227 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 1223 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
1228 "Peer `%s' disconnected from us\n", 1224 "Peer `%s' disconnected from us\n",
1229 GNUNET_i2s (peer)); 1225 GNUNET_i2s(peer));
1230 GNUNET_assert (GNUNET_YES == 1226 GNUNET_assert(GNUNET_YES ==
1231 GNUNET_CONTAINER_multipeermap_remove (peers, peer, pos)); 1227 GNUNET_CONTAINER_multipeermap_remove(peers, peer, pos));
1232 if (NULL != pos->transmit_task) 1228 if (NULL != pos->transmit_task)
1233 { 1229 {
1234 GNUNET_SCHEDULER_cancel (pos->transmit_task); 1230 GNUNET_SCHEDULER_cancel(pos->transmit_task);
1235 pos->transmit_task = NULL; 1231 pos->transmit_task = NULL;
1236 } 1232 }
1237 GNUNET_free (pos); 1233 GNUNET_free(pos);
1238 GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO); 1234 GNUNET_STATISTICS_update(stats, "# peers connected", -1, GNUNET_NO);
1239} 1235}
1240 1236
1241 1237
@@ -1248,11 +1244,11 @@ handle_core_disconnect (void *cls,
1248 * @param size the amount of data sent (ignored) 1244 * @param size the amount of data sent (ignored)
1249 */ 1245 */
1250static void 1246static void
1251flush_comp_cb (void *cls, size_t size) 1247flush_comp_cb(void *cls, size_t size)
1252{ 1248{
1253 (void) cls; 1249 (void)cls;
1254 (void) size; 1250 (void)size;
1255 GNUNET_TESTBED_LOGGER_disconnect (lh); 1251 GNUNET_TESTBED_LOGGER_disconnect(lh);
1256 lh = NULL; 1252 lh = NULL;
1257} 1253}
1258#endif 1254#endif
@@ -1264,60 +1260,60 @@ flush_comp_cb (void *cls, size_t size)
1264 * @param cls unused 1260 * @param cls unused
1265 */ 1261 */
1266static void 1262static void
1267shutdown_task (void *cls) 1263shutdown_task(void *cls)
1268{ 1264{
1269 (void) cls; 1265 (void)cls;
1270 if (NULL != flood_task) 1266 if (NULL != flood_task)
1271 { 1267 {
1272 GNUNET_SCHEDULER_cancel (flood_task); 1268 GNUNET_SCHEDULER_cancel(flood_task);
1273 flood_task = NULL; 1269 flood_task = NULL;
1274 } 1270 }
1275 if (NULL != proof_task) 1271 if (NULL != proof_task)
1276 { 1272 {
1277 GNUNET_SCHEDULER_cancel (proof_task); 1273 GNUNET_SCHEDULER_cancel(proof_task);
1278 proof_task = NULL; 1274 proof_task = NULL;
1279 write_proof (); /* remember progress */ 1275 write_proof(); /* remember progress */
1280 } 1276 }
1281 if (NULL != nc) 1277 if (NULL != nc)
1282 { 1278 {
1283 GNUNET_notification_context_destroy (nc); 1279 GNUNET_notification_context_destroy(nc);
1284 nc = NULL; 1280 nc = NULL;
1285 } 1281 }
1286 if (NULL != core_api) 1282 if (NULL != core_api)
1287 { 1283 {
1288 GNUNET_CORE_disconnect (core_api); 1284 GNUNET_CORE_disconnect(core_api);
1289 core_api = NULL; 1285 core_api = NULL;
1290 } 1286 }
1291 if (NULL != stats) 1287 if (NULL != stats)
1292 { 1288 {
1293 GNUNET_STATISTICS_destroy (stats, GNUNET_NO); 1289 GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
1294 stats = NULL; 1290 stats = NULL;
1295 } 1291 }
1296 if (NULL != peers) 1292 if (NULL != peers)
1297 { 1293 {
1298 GNUNET_CONTAINER_multipeermap_destroy (peers); 1294 GNUNET_CONTAINER_multipeermap_destroy(peers);
1299 peers = NULL; 1295 peers = NULL;
1300 } 1296 }
1301 if (NULL != my_private_key) 1297 if (NULL != my_private_key)
1302 { 1298 {
1303 GNUNET_free (my_private_key); 1299 GNUNET_free(my_private_key);
1304 my_private_key = NULL; 1300 my_private_key = NULL;
1305 } 1301 }
1306#if ENABLE_NSE_HISTOGRAM 1302#if ENABLE_NSE_HISTOGRAM
1307 if (NULL != logger_test) 1303 if (NULL != logger_test)
1308 { 1304 {
1309 GNUNET_CLIENT_service_test_cancel (logger_test); 1305 GNUNET_CLIENT_service_test_cancel(logger_test);
1310 logger_test = NULL; 1306 logger_test = NULL;
1311 } 1307 }
1312 if (NULL != lh) 1308 if (NULL != lh)
1313 { 1309 {
1314 GNUNET_TESTBED_LOGGER_flush (lh, &flush_comp_cb, NULL); 1310 GNUNET_TESTBED_LOGGER_flush(lh, &flush_comp_cb, NULL);
1315 } 1311 }
1316 if (NULL != histogram) 1312 if (NULL != histogram)
1317 { 1313 {
1318 GNUNET_BIO_write_close (histogram); 1314 GNUNET_BIO_write_close(histogram);
1319 histogram = NULL; 1315 histogram = NULL;
1320 } 1316 }
1321#endif 1317#endif
1322} 1318}
1323 1319
@@ -1329,38 +1325,38 @@ shutdown_task (void *cls)
1329 * @param identity the public identity of this peer 1325 * @param identity the public identity of this peer
1330 */ 1326 */
1331static void 1327static void
1332core_init (void *cls, const struct GNUNET_PeerIdentity *identity) 1328core_init(void *cls, const struct GNUNET_PeerIdentity *identity)
1333{ 1329{
1334 struct GNUNET_TIME_Absolute now; 1330 struct GNUNET_TIME_Absolute now;
1335 struct GNUNET_TIME_Absolute prev_time; 1331 struct GNUNET_TIME_Absolute prev_time;
1336 1332
1337 (void) cls; 1333 (void)cls;
1338 if (NULL == identity) 1334 if (NULL == identity)
1339 { 1335 {
1340 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n"); 1336 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
1341 GNUNET_SCHEDULER_shutdown (); 1337 GNUNET_SCHEDULER_shutdown();
1342 return; 1338 return;
1343 } 1339 }
1344 GNUNET_assert (0 == GNUNET_memcmp (&my_identity, identity)); 1340 GNUNET_assert(0 == GNUNET_memcmp(&my_identity, identity));
1345 now = GNUNET_TIME_absolute_get (); 1341 now = GNUNET_TIME_absolute_get();
1346 current_timestamp.abs_value_us = 1342 current_timestamp.abs_value_us =
1347 (now.abs_value_us / gnunet_nse_interval.rel_value_us) * 1343 (now.abs_value_us / gnunet_nse_interval.rel_value_us) *
1348 gnunet_nse_interval.rel_value_us; 1344 gnunet_nse_interval.rel_value_us;
1349 next_timestamp = 1345 next_timestamp =
1350 GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval); 1346 GNUNET_TIME_absolute_add(current_timestamp, gnunet_nse_interval);
1351 estimate_index = HISTORY_SIZE - 1; 1347 estimate_index = HISTORY_SIZE - 1;
1352 estimate_count = 0; 1348 estimate_count = 0;
1353 if (GNUNET_YES == check_proof_of_work (&my_identity.public_key, my_proof)) 1349 if (GNUNET_YES == check_proof_of_work(&my_identity.public_key, my_proof))
1354 { 1350 {
1355 int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE; 1351 int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
1356 prev_time.abs_value_us = 1352 prev_time.abs_value_us =
1357 current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us; 1353 current_timestamp.abs_value_us - gnunet_nse_interval.rel_value_us;
1358 setup_flood_message (idx, prev_time); 1354 setup_flood_message(idx, prev_time);
1359 setup_flood_message (estimate_index, current_timestamp); 1355 setup_flood_message(estimate_index, current_timestamp);
1360 estimate_count++; 1356 estimate_count++;
1361 } 1357 }
1362 flood_task = 1358 flood_task =
1363 GNUNET_SCHEDULER_add_at (next_timestamp, &update_flood_message, NULL); 1359 GNUNET_SCHEDULER_add_at(next_timestamp, &update_flood_message, NULL);
1364} 1360}
1365 1361
1366 1362
@@ -1374,21 +1370,21 @@ core_init (void *cls, const struct GNUNET_PeerIdentity *identity)
1374 * #GNUNET_SYSERR if the configuration is invalid 1370 * #GNUNET_SYSERR if the configuration is invalid
1375 */ 1371 */
1376static void 1372static void
1377status_cb (void *cls, int status) 1373status_cb(void *cls, int status)
1378{ 1374{
1379 (void) cls; 1375 (void)cls;
1380 logger_test = NULL; 1376 logger_test = NULL;
1381 if (GNUNET_YES != status) 1377 if (GNUNET_YES != status)
1382 { 1378 {
1383 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n"); 1379 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Testbed logger not running\n");
1384 return; 1380 return;
1385 } 1381 }
1386 if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg))) 1382 if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect(cfg)))
1387 { 1383 {
1388 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 1384 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
1389 "Cannot connect to the testbed logger. Exiting.\n"); 1385 "Cannot connect to the testbed logger. Exiting.\n");
1390 GNUNET_SCHEDULER_shutdown (); 1386 GNUNET_SCHEDULER_shutdown();
1391 } 1387 }
1392} 1388}
1393#endif 1389#endif
1394 1390
@@ -1401,127 +1397,127 @@ status_cb (void *cls, int status)
1401 * @param service the initialized service 1397 * @param service the initialized service
1402 */ 1398 */
1403static void 1399static void
1404run (void *cls, 1400run(void *cls,
1405 const struct GNUNET_CONFIGURATION_Handle *c, 1401 const struct GNUNET_CONFIGURATION_Handle *c,
1406 struct GNUNET_SERVICE_Handle *service) 1402 struct GNUNET_SERVICE_Handle *service)
1407{ 1403{
1408 struct GNUNET_MQ_MessageHandler core_handlers[] = 1404 struct GNUNET_MQ_MessageHandler core_handlers[] =
1409 {GNUNET_MQ_hd_fixed_size (p2p_estimate, 1405 { GNUNET_MQ_hd_fixed_size(p2p_estimate,
1410 GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD, 1406 GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
1411 struct GNUNET_NSE_FloodMessage, 1407 struct GNUNET_NSE_FloodMessage,
1412 NULL), 1408 NULL),
1413 GNUNET_MQ_handler_end ()}; 1409 GNUNET_MQ_handler_end() };
1414 char *proof; 1410 char *proof;
1415 struct GNUNET_CRYPTO_EddsaPrivateKey *pk; 1411 struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
1416 1412
1417 (void) cls; 1413 (void)cls;
1418 (void) service; 1414 (void)service;
1419 cfg = c; 1415 cfg = c;
1420 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, 1416 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(cfg,
1421 "NSE", 1417 "NSE",
1422 "INTERVAL", 1418 "INTERVAL",
1423 &gnunet_nse_interval)) 1419 &gnunet_nse_interval))
1424 { 1420 {
1425 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL"); 1421 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "INTERVAL");
1426 GNUNET_SCHEDULER_shutdown (); 1422 GNUNET_SCHEDULER_shutdown();
1427 return; 1423 return;
1428 } 1424 }
1429 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (cfg, 1425 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(cfg,
1430 "NSE", 1426 "NSE",
1431 "WORKDELAY", 1427 "WORKDELAY",
1432 &proof_find_delay)) 1428 &proof_find_delay))
1433 { 1429 {
1434 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY"); 1430 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKDELAY");
1435 GNUNET_SCHEDULER_shutdown (); 1431 GNUNET_SCHEDULER_shutdown();
1436 return; 1432 return;
1437 } 1433 }
1438 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, 1434 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
1439 "NSE", 1435 "NSE",
1440 "WORKBITS", 1436 "WORKBITS",
1441 &nse_work_required)) 1437 &nse_work_required))
1442 { 1438 {
1443 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS"); 1439 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
1444 GNUNET_SCHEDULER_shutdown (); 1440 GNUNET_SCHEDULER_shutdown();
1445 return; 1441 return;
1446 } 1442 }
1447 if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8) 1443 if (nse_work_required >= sizeof(struct GNUNET_HashCode) * 8)
1448 { 1444 {
1449 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, 1445 GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
1450 "NSE", 1446 "NSE",
1451 "WORKBITS", 1447 "WORKBITS",
1452 _ ("Value is too large.\n")); 1448 _("Value is too large.\n"));
1453 GNUNET_SCHEDULER_shutdown (); 1449 GNUNET_SCHEDULER_shutdown();
1454 return; 1450 return;
1455 } 1451 }
1456 1452
1457#if ENABLE_NSE_HISTOGRAM 1453#if ENABLE_NSE_HISTOGRAM
1458 { 1454 {
1459 char *histogram_dir; 1455 char *histogram_dir;
1460 char *histogram_fn; 1456 char *histogram_fn;
1461 1457
1462 if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, 1458 if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg,
1463 "NSE", 1459 "NSE",
1464 "HISTOGRAM_DIR", 1460 "HISTOGRAM_DIR",
1465 &histogram_dir)) 1461 &histogram_dir))
1466 { 1462 {
1467 GNUNET_assert ( 1463 GNUNET_assert(
1468 0 < GNUNET_asprintf (&histogram_fn, "%s/timestamps", histogram_dir)); 1464 0 < GNUNET_asprintf(&histogram_fn, "%s/timestamps", histogram_dir));
1469 GNUNET_free (histogram_dir); 1465 GNUNET_free(histogram_dir);
1470 histogram = GNUNET_BIO_write_open (histogram_fn); 1466 histogram = GNUNET_BIO_write_open(histogram_fn);
1471 if (NULL == histogram) 1467 if (NULL == histogram)
1472 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 1468 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
1473 "Unable to open histogram file `%s'\n", 1469 "Unable to open histogram file `%s'\n",
1474 histogram_fn); 1470 histogram_fn);
1475 GNUNET_free (histogram_fn); 1471 GNUNET_free(histogram_fn);
1476 } 1472 }
1477 logger_test = GNUNET_CLIENT_service_test ("testbed-logger", 1473 logger_test = GNUNET_CLIENT_service_test("testbed-logger",
1478 cfg, 1474 cfg,
1479 GNUNET_TIME_UNIT_SECONDS, 1475 GNUNET_TIME_UNIT_SECONDS,
1480 &status_cb, 1476 &status_cb,
1481 NULL); 1477 NULL);
1482 } 1478 }
1483#endif 1479#endif
1484 1480
1485 GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); 1481 GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
1486 pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg); 1482 pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
1487 GNUNET_assert (NULL != pk); 1483 GNUNET_assert(NULL != pk);
1488 my_private_key = pk; 1484 my_private_key = pk;
1489 GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key); 1485 GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key);
1490 if (GNUNET_OK != 1486 if (GNUNET_OK !=
1491 GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof)) 1487 GNUNET_CONFIGURATION_get_value_filename(cfg, "NSE", "PROOFFILE", &proof))
1492 { 1488 {
1493 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE"); 1489 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "NSE", "PROOFFILE");
1494 GNUNET_free (my_private_key); 1490 GNUNET_free(my_private_key);
1495 my_private_key = NULL; 1491 my_private_key = NULL;
1496 GNUNET_SCHEDULER_shutdown (); 1492 GNUNET_SCHEDULER_shutdown();
1497 return; 1493 return;
1498 } 1494 }
1499 if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) || 1495 if ((GNUNET_YES != GNUNET_DISK_file_test(proof)) ||
1500 (sizeof (my_proof) != 1496 (sizeof(my_proof) !=
1501 GNUNET_DISK_fn_read (proof, &my_proof, sizeof (my_proof)))) 1497 GNUNET_DISK_fn_read(proof, &my_proof, sizeof(my_proof))))
1502 my_proof = 0; 1498 my_proof = 0;
1503 GNUNET_free (proof); 1499 GNUNET_free(proof);
1504 proof_task = 1500 proof_task =
1505 GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, 1501 GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE,
1506 &find_proof, 1502 &find_proof,
1507 NULL); 1503 NULL);
1508 1504
1509 peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES); 1505 peers = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_YES);
1510 nc = GNUNET_notification_context_create (1); 1506 nc = GNUNET_notification_context_create(1);
1511 /* Connect to core service and register core handlers */ 1507 /* Connect to core service and register core handlers */
1512 core_api = 1508 core_api =
1513 GNUNET_CORE_connect (cfg, /* Main configuration */ 1509 GNUNET_CORE_connect(cfg, /* Main configuration */
1514 NULL, /* Closure passed to functions */ 1510 NULL, /* Closure passed to functions */
1515 &core_init, /* Call core_init once connected */ 1511 &core_init, /* Call core_init once connected */
1516 &handle_core_connect, /* Handle connects */ 1512 &handle_core_connect, /* Handle connects */
1517 &handle_core_disconnect, /* Handle disconnects */ 1513 &handle_core_disconnect, /* Handle disconnects */
1518 core_handlers); /* Register these handlers */ 1514 core_handlers); /* Register these handlers */
1519 if (NULL == core_api) 1515 if (NULL == core_api)
1520 { 1516 {
1521 GNUNET_SCHEDULER_shutdown (); 1517 GNUNET_SCHEDULER_shutdown();
1522 return; 1518 return;
1523 } 1519 }
1524 stats = GNUNET_STATISTICS_create ("nse", cfg); 1520 stats = GNUNET_STATISTICS_create("nse", cfg);
1525} 1521}
1526 1522
1527 1523
@@ -1534,12 +1530,12 @@ run (void *cls,
1534 * @return @a c 1530 * @return @a c
1535 */ 1531 */
1536static void * 1532static void *
1537client_connect_cb (void *cls, 1533client_connect_cb(void *cls,
1538 struct GNUNET_SERVICE_Client *c, 1534 struct GNUNET_SERVICE_Client *c,
1539 struct GNUNET_MQ_Handle *mq) 1535 struct GNUNET_MQ_Handle *mq)
1540{ 1536{
1541 (void) cls; 1537 (void)cls;
1542 (void) mq; 1538 (void)mq;
1543 return c; 1539 return c;
1544} 1540}
1545 1541
@@ -1552,29 +1548,29 @@ client_connect_cb (void *cls,
1552 * @param internal_cls should be equal to @a c 1548 * @param internal_cls should be equal to @a c
1553 */ 1549 */
1554static void 1550static void
1555client_disconnect_cb (void *cls, 1551client_disconnect_cb(void *cls,
1556 struct GNUNET_SERVICE_Client *c, 1552 struct GNUNET_SERVICE_Client *c,
1557 void *internal_cls) 1553 void *internal_cls)
1558{ 1554{
1559 (void) cls; 1555 (void)cls;
1560 GNUNET_assert (c == internal_cls); 1556 GNUNET_assert(c == internal_cls);
1561} 1557}
1562 1558
1563 1559
1564/** 1560/**
1565 * Define "main" method using service macro. 1561 * Define "main" method using service macro.
1566 */ 1562 */
1567GNUNET_SERVICE_MAIN ("nse", 1563GNUNET_SERVICE_MAIN("nse",
1568 GNUNET_SERVICE_OPTION_NONE, 1564 GNUNET_SERVICE_OPTION_NONE,
1569 &run, 1565 &run,
1570 &client_connect_cb, 1566 &client_connect_cb,
1571 &client_disconnect_cb, 1567 &client_disconnect_cb,
1572 NULL, 1568 NULL,
1573 GNUNET_MQ_hd_fixed_size (start, 1569 GNUNET_MQ_hd_fixed_size(start,
1574 GNUNET_MESSAGE_TYPE_NSE_START, 1570 GNUNET_MESSAGE_TYPE_NSE_START,
1575 struct GNUNET_MessageHeader, 1571 struct GNUNET_MessageHeader,
1576 NULL), 1572 NULL),
1577 GNUNET_MQ_handler_end ()); 1573 GNUNET_MQ_handler_end());
1578 1574
1579 1575
1580#if defined(LINUX) && defined(__GLIBC__) 1576#if defined(LINUX) && defined(__GLIBC__)
@@ -1583,11 +1579,11 @@ GNUNET_SERVICE_MAIN ("nse",
1583/** 1579/**
1584 * MINIMIZE heap size (way below 128k) since this process doesn't need much. 1580 * MINIMIZE heap size (way below 128k) since this process doesn't need much.
1585 */ 1581 */
1586void __attribute__ ((constructor)) GNUNET_ARM_memory_init () 1582void __attribute__ ((constructor)) GNUNET_ARM_memory_init()
1587{ 1583{
1588 mallopt (M_TRIM_THRESHOLD, 4 * 1024); 1584 mallopt(M_TRIM_THRESHOLD, 4 * 1024);
1589 mallopt (M_TOP_PAD, 1 * 1024); 1585 mallopt(M_TOP_PAD, 1 * 1024);
1590 malloc_trim (0); 1586 malloc_trim(0);
1591} 1587}
1592#endif 1588#endif
1593 1589