src/nse/gnunet-service-nse.c

   1 /*
   2   This file is part of GNUnet.
   3   (C) 2009, 2010, 2011, 2012, 2013 Christian Grothoff (and other contributing authors)
   4
   5   GNUnet is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published
   7   by the Free Software Foundation; either version 3, or (at your
   8   option) any later version.
   9
  10   GNUnet is distributed in the hope that it will be useful, but
  11   WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13   General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with GNUnet; see the file COPYING.  If not, write to the
  17   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18   Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * @file nse/gnunet-service-nse.c
  23  * @brief network size estimation service
  24  * @author Nathan Evans
  25  * @author Christian Grothoff
  26  *
  27  * The purpose of this service is to estimate the size of the network.
  28  * Given a specified interval, each peer hashes the most recent
  29  * timestamp which is evenly divisible by that interval.  This hash is
  30  * compared in distance to the peer identity to choose an offset.  The
  31  * closer the peer identity to the hashed timestamp, the earlier the
  32  * peer sends out a "nearest peer" message.  The closest peer's
  33  * message should thus be received before any others, which stops
  34  * those peer from sending their messages at a later duration.  So
  35  * every peer should receive the same nearest peer message, and from
  36  * this can calculate the expected number of peers in the network.
  37  */
  38 #include "platform.h"
  39 #include <math.h>
  40 #include "gnunet_util_lib.h"
  41 #include "gnunet_constants.h"
  42 #include "gnunet_protocols.h"
  43 #include "gnunet_signatures.h"
  44 #include "gnunet_statistics_service.h"
  45 #include "gnunet_core_service.h"
  46 #include "gnunet_nse_service.h"
  47 #if ENABLE_NSE_HISTOGRAM
  48 #include "gnunet_testbed_logger_service.h"
  49 #endif
  50 #include "nse.h"
  51 #include <gcrypt.h>
  52
  53
  54 /**
  55  * Should messages be delayed randomly?  This option should be set to
  56  * GNUNET_NO only for experiments, not in production.  It should also
  57  * be removed once the initial experiments have been completed.
  58  */
  59 #define USE_RANDOM_DELAYS GNUNET_YES
  60
  61 /**
  62  * Generate extensive debug-level log messages?
  63  */
  64 #define DEBUG_NSE GNUNET_NO
  65
  66 /**
  67  * Over how many values do we calculate the weighted average?
  68  */
  69 #define HISTORY_SIZE 64
  70
  71 /**
  72  * Message priority to use.
  73  */
  74 #define NSE_PRIORITY 5
  75
  76 #if FREEBSD
  77 #define log2(a) (log(a)/log(2))
  78 #endif
  79
  80 /**
  81  * Amount of work required (W-bit collisions) for NSE proofs, in collision-bits.
  82  */
  83 static unsigned long long nse_work_required;
  84
  85 /**
  86  * Interval for sending network size estimation flood requests.
  87  */
  88 static struct GNUNET_TIME_Relative gnunet_nse_interval;
  89
  90 /**
  91  * Interval between proof find runs.
  92  */
  93 static struct GNUNET_TIME_Relative proof_find_delay;
  94
  95 #if ENABLE_NSE_HISTOGRAM
  96 /**
  97  * Handle for writing when we received messages to disk.
  98  */
  99 static struct GNUNET_TESTBED_LOGGER_Handle *lh;
 100 #endif
 101
 102
 103 /**
 104  * Per-peer information.
 105  */
 106 struct NSEPeerEntry
 107 {
 108
 109   /**
 110    * Core handle for sending messages to this peer.
 111    */
 112   struct GNUNET_CORE_TransmitHandle *th;
 113
 114   /**
 115    * What is the identity of the peer?
 116    */
 117   struct GNUNET_PeerIdentity id;
 118
 119   /**
 120    * Task scheduled to send message to this peer.
 121    */
 122   GNUNET_SCHEDULER_TaskIdentifier transmit_task;
 123
 124   /**
 125    * Did we receive or send a message about the previous round
 126    * to this peer yet?   GNUNET_YES if the previous round has
 127    * been taken care of.
 128    */
 129   int previous_round;
 130
 131 #if ENABLE_NSE_HISTOGRAM
 132
 133   /**
 134    * Amount of messages received from this peer on this round.
 135    */
 136   unsigned int received_messages;
 137
 138   /**
 139    * Amount of messages transmitted to this peer on this round.
 140    */
 141   unsigned int transmitted_messages;
 142
 143   /**
 144    * Which size did we tell the peer the network is?
 145    */
 146   unsigned int last_transmitted_size;
 147
 148 #endif
 149
 150 };
 151
 152
 153 GNUNET_NETWORK_STRUCT_BEGIN
 154
 155 /**
 156  * Network size estimate reply; sent when "this"
 157  * peer's timer has run out before receiving a
 158  * valid reply from another peer.
 159  */
 160 struct GNUNET_NSE_FloodMessage
 161 {
 162   /**
 163    * Type: GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD
 164    */
 165   struct GNUNET_MessageHeader header;
 166
 167   /**
 168    * Number of hops this message has taken so far.
 169    */
 170   uint32_t hop_count GNUNET_PACKED;
 171
 172   /**
 173    * Purpose.
 174    */
 175   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 176
 177   /**
 178    * The current timestamp value (which all
 179    * peers should agree on).
 180    */
 181   struct GNUNET_TIME_AbsoluteNBO timestamp;
 182
 183   /**
 184    * Number of matching bits between the hash
 185    * of timestamp and the initiator's public
 186    * key.
 187    */
 188   uint32_t matching_bits GNUNET_PACKED;
 189
 190   /**
 191    * Public key of the originator.
 192    */
 193   struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
 194
 195   /**
 196    * Proof of work, causing leading zeros when hashed with pkey.
 197    */
 198   uint64_t proof_of_work GNUNET_PACKED;
 199
 200   /**
 201    * Signature (over range specified in purpose).
 202    */
 203   struct GNUNET_CRYPTO_EccSignature signature;
 204 };
 205 GNUNET_NETWORK_STRUCT_END
 206
 207 /**
 208  * Handle to our current configuration.
 209  */
 210 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 211
 212 /**
 213  * Handle to the statistics service.
 214  */
 215 static struct GNUNET_STATISTICS_Handle *stats;
 216
 217 /**
 218  * Handle to the core service.
 219  */
 220 static struct GNUNET_CORE_Handle *coreAPI;
 221
 222 /**
 223  * Map of all connected peers.
 224  */
 225 static struct GNUNET_CONTAINER_MultiHashMap *peers;
 226
 227 /**
 228  * The current network size estimate.  Number of bits matching on
 229  * average thus far.
 230  */
 231 static double current_size_estimate;
 232
 233 /**
 234  * The standard deviation of the last HISTORY_SIZE network
 235  * size estimates.
 236  */
 237 static double current_std_dev = NAN;
 238
 239 /**
 240  * Current hop counter estimate (estimate for network diameter).
 241  */
 242 static uint32_t hop_count_max;
 243
 244 /**
 245  * Message for the next round, if we got any.
 246  */
 247 static struct GNUNET_NSE_FloodMessage next_message;
 248
 249 /**
 250  * Array of recent size estimate messages.
 251  */
 252 static struct GNUNET_NSE_FloodMessage size_estimate_messages[HISTORY_SIZE];
 253
 254 /**
 255  * Index of most recent estimate.
 256  */
 257 static unsigned int estimate_index;
 258
 259 /**
 260  * Number of valid entries in the history.
 261  */
 262 static unsigned int estimate_count;
 263
 264 /**
 265  * Task scheduled to update our flood message for the next round.
 266  */
 267 static GNUNET_SCHEDULER_TaskIdentifier flood_task;
 268
 269 /**
 270  * Task scheduled to compute our proof.
 271  */
 272 static GNUNET_SCHEDULER_TaskIdentifier proof_task;
 273
 274 /**
 275  * Notification context, simplifies client broadcasts.
 276  */
 277 static struct GNUNET_SERVER_NotificationContext *nc;
 278
 279 /**
 280  * The next major time.
 281  */
 282 static struct GNUNET_TIME_Absolute next_timestamp;
 283
 284 /**
 285  * The current major time.
 286  */
 287 static struct GNUNET_TIME_Absolute current_timestamp;
 288
 289 /**
 290  * The public key of this peer.
 291  */
 292 static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded my_public_key;
 293
 294 /**
 295  * The private key of this peer.
 296  */
 297 static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
 298
 299 /**
 300  * The peer identity of this peer.
 301  */
 302 static struct GNUNET_PeerIdentity my_identity;
 303
 304 /**
 305  * Proof of work for this peer.
 306  */
 307 static uint64_t my_proof;
 308
 309 /**
 310  * Handle to this serivce's server.
 311  */
 312 static struct GNUNET_SERVER_Handle *srv;
 313
 314
 315 /**
 316  * Initialize a message to clients with the current network
 317  * size estimate.
 318  *
 319  * @param em message to fill in
 320  */
 321 static void
 322 setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
 323 {
 324   unsigned int i;
 325   unsigned int j;
 326   double mean;
 327   double sum;
 328   double std_dev;
 329   double variance;
 330   double val;
 331   double nsize;
 332
 333 #define WEST 1
 334   /* Weighted incremental algorithm for stddev according to West (1979) */
 335 #if WEST
 336   double sumweight;
 337   double weight;
 338   double q;
 339   double r;
 340   double temp;
 341
 342   mean = 0.0;
 343   sum = 0.0;
 344   sumweight = 0.0;
 345   variance = 0.0;
 346   for (i = 0; i < estimate_count; i++)
 347   {
 348     j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 349     val = htonl (size_estimate_messages[j].matching_bits);
 350     weight = estimate_count + 1 - i;
 351
 352     temp = weight + sumweight;
 353     q = val - mean;
 354     r = q * weight / temp;
 355     mean += r;
 356     sum += sumweight * q * r;
 357     sumweight = temp;
 358   }
 359   if (estimate_count > 0)
 360     variance = (sum / sumweight) * estimate_count / (estimate_count - 1.0);
 361 #else
 362   /* trivial version for debugging */
 363   double vsq;
 364
 365   /* non-weighted trivial version */
 366   sum = 0.0;
 367   vsq = 0.0;
 368   variance = 0.0;
 369   mean = 0.0;
 370
 371   for (i = 0; i < estimate_count; i++)
 372   {
 373     j = (estimate_index - i + HISTORY_SIZE) % HISTORY_SIZE;
 374     val = htonl (size_estimate_messages[j].matching_bits);
 375     sum += val;
 376     vsq += val * val;
 377   }
 378   if (0 != estimate_count)
 379   {
 380     mean = sum / estimate_count;
 381     variance = (vsq - mean * sum) / (estimate_count - 1.0);     // terrible for numerical stability...
 382   }
 383 #endif
 384   if (variance >= 0)
 385     std_dev = sqrt (variance);
 386   else
 387     std_dev = variance;         /* must be infinity due to estimate_count == 0 */
 388   current_std_dev = std_dev;
 389   current_size_estimate = mean;
 390
 391   em->header.size = htons (sizeof (struct GNUNET_NSE_ClientMessage));
 392   em->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_ESTIMATE);
 393   em->reserved = htonl (0);
 394   em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
 395   double se = mean - 0.332747;
 396   nsize = log2 (GNUNET_CONTAINER_multihashmap_size (peers) + 1);
 397   em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
 398   em->std_deviation = GNUNET_hton_double (std_dev);
 399   GNUNET_STATISTICS_set (stats, "# nodes in the network (estimate)",
 400                          (uint64_t) pow (2, mean - 1.0 / 3.0), GNUNET_NO);
 401 }
 402
 403
 404 /**
 405  * Handler for START message from client, triggers an
 406  * immediate current network estimate notification.
 407  * Also, we remember the client for updates upon future
 408  * estimate measurements.
 409  *
 410  * @param cls unused
 411  * @param client who sent the message
 412  * @param message the message received
 413  */
 414 static void
 415 handle_start_message (void *cls, struct GNUNET_SERVER_Client *client,
 416                       const struct GNUNET_MessageHeader *message)
 417 {
 418   struct GNUNET_NSE_ClientMessage em;
 419
 420   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received START message from client\n");
 421   GNUNET_SERVER_notification_context_add (nc, client);
 422   setup_estimate_message (&em);
 423   GNUNET_SERVER_notification_context_unicast (nc, client, &em.header,
 424                                               GNUNET_YES);
 425   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 426 }
 427
 428
 429 /**
 430  * How long should we delay a message to go the given number of
 431  * matching bits?
 432  *
 433  * @param matching_bits number of matching bits to consider
 434  */
 435 static double
 436 get_matching_bits_delay (uint32_t matching_bits)
 437 {
 438   /* Calculated as: S + f/2 - (f / pi) * (atan(x - p')) */
 439   // S is next_timestamp (ignored in return value)
 440   // f is frequency (gnunet_nse_interval)
 441   // x is matching_bits
 442   // p' is current_size_estimate
 443   return ((double) gnunet_nse_interval.rel_value / (double) 2.0) -
 444       ((gnunet_nse_interval.rel_value / M_PI) *
 445        atan (matching_bits - current_size_estimate));
 446 }
 447
 448
 449 /**
 450  * What delay randomization should we apply for a given number of matching bits?
 451  *
 452  * @param matching_bits number of matching bits
 453  * @return random delay to apply
 454  */
 455 static struct GNUNET_TIME_Relative
 456 get_delay_randomization (uint32_t matching_bits)
 457 {
 458 #if USE_RANDOM_DELAYS
 459   struct GNUNET_TIME_Relative ret;
 460   uint32_t i;
 461   double d;
 462
 463   d = get_matching_bits_delay (matching_bits);
 464   i = (uint32_t) (d / (double) (hop_count_max + 1));
 465   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 466               "Randomizing flood using latencies up to %u ms\n",
 467               (unsigned int) i);
 468   ret.rel_value = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, i + 1);
 469   return ret;
 470 #else
 471   return GNUNET_TIME_UNIT_ZERO;
 472 #endif
 473 }
 474
 475
 476 /**
 477  * Calculate the 'proof-of-work' hash (an expensive hash).
 478  *
 479  * @param buf data to hash
 480  * @param buf_len number of bytes in 'buf'
 481  * @param result where to write the resulting hash
 482  */
 483 static void
 484 pow_hash (const void *buf,
 485           size_t buf_len,
 486           struct GNUNET_HashCode *result)
 487 {
 488   GNUNET_break (0 ==
 489                 gcry_kdf_derive (buf, buf_len,
 490                                  GCRY_KDF_SCRYPT,
 491                                  1 /* subalgo */,
 492                                  "gnunet-proof-of-work", strlen ("gnunet-proof-of-work"),
 493                                  2 /* iterations; keep cost of individual op small */,
 494                                  sizeof (struct GNUNET_HashCode), result));
 495 }
 496
 497
 498 /**
 499  * Get the number of matching bits that the given timestamp has to the given peer ID.
 500  *
 501  * @param timestamp time to generate key
 502  * @param id peer identity to compare with
 503  * @return number of matching bits
 504  */
 505 static uint32_t
 506 get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
 507                    const struct GNUNET_PeerIdentity *id)
 508 {
 509   struct GNUNET_HashCode timestamp_hash;
 510
 511   GNUNET_CRYPTO_hash (&timestamp.abs_value, sizeof (timestamp.abs_value),
 512                       &timestamp_hash);
 513   return GNUNET_CRYPTO_hash_matching_bits (&timestamp_hash, &id->hashPubKey);
 514 }
 515
 516
 517 /**
 518  * Get the transmission delay that should be applied for a
 519  * particular round.
 520  *
 521  * @param round_offset -1 for the previous round (random delay between 0 and 50ms)
 522  *                      0 for the current round (based on our proximity to time key)
 523  * @return delay that should be applied
 524  */
 525 static struct GNUNET_TIME_Relative
 526 get_transmit_delay (int round_offset)
 527 {
 528   struct GNUNET_TIME_Relative ret;
 529   struct GNUNET_TIME_Absolute tgt;
 530   double dist_delay;
 531   uint32_t matching_bits;
 532
 533   switch (round_offset)
 534   {
 535   case -1:
 536     /* previous round is randomized between 0 and 50 ms */
 537 #if USE_RANDOM_DELAYS
 538     ret.rel_value = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, 50);
 539 #else
 540     ret = GNUNET_TIME_UNIT_ZERO;
 541 #endif
 542     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 543                 "Transmitting previous round behind schedule in %llu ms\n",
 544                 (unsigned long long) ret.rel_value);
 545     return ret;
 546   case 0:
 547     /* current round is based on best-known matching_bits */
 548     matching_bits =
 549         ntohl (size_estimate_messages[estimate_index].matching_bits);
 550     dist_delay = get_matching_bits_delay (matching_bits);
 551     dist_delay += get_delay_randomization (matching_bits).rel_value;
 552     ret.rel_value = (uint64_t) dist_delay;
 553     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 554                 "For round %llu, delay for %u matching bits is %llu ms\n",
 555                 (unsigned long long) current_timestamp.abs_value,
 556                 (unsigned int) matching_bits,
 557                 (unsigned long long) ret.rel_value);
 558     /* now consider round start time and add delay to it */
 559     tgt = GNUNET_TIME_absolute_add (current_timestamp, ret);
 560     return GNUNET_TIME_absolute_get_remaining (tgt);
 561   }
 562   GNUNET_break (0);
 563   return GNUNET_TIME_UNIT_FOREVER_REL;
 564 }
 565
 566
 567 /**
 568  * Task that triggers a NSE P2P transmission.
 569  *
 570  * @param cls the 'struct NSEPeerEntry'
 571  * @param tc scheduler context
 572  */
 573 static void
 574 transmit_task_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 575
 576
 577 /**
 578  * Called when core is ready to send a message we asked for
 579  * out to the destination.
 580  *
 581  * @param cls closure (NULL)
 582  * @param size number of bytes available in buf
 583  * @param buf where the callee should write the message
 584  * @return number of bytes written to buf
 585  */
 586 static size_t
 587 transmit_ready (void *cls, size_t size, void *buf)
 588 {
 589   struct NSEPeerEntry *peer_entry = cls;
 590   unsigned int idx;
 591
 592   peer_entry->th = NULL;
 593   if (NULL == buf)
 594   {
 595     /* client disconnected */
 596     return 0;
 597   }
 598   GNUNET_assert (size >= sizeof (struct GNUNET_NSE_FloodMessage));
 599   idx = estimate_index;
 600   if (GNUNET_NO == peer_entry->previous_round)
 601   {
 602     idx = (idx + HISTORY_SIZE - 1) % HISTORY_SIZE;
 603     peer_entry->previous_round = GNUNET_YES;
 604     peer_entry->transmit_task =
 605         GNUNET_SCHEDULER_add_delayed (get_transmit_delay (0), &transmit_task_cb,
 606                                       peer_entry);
 607   }
 608   if ((0 == ntohl (size_estimate_messages[idx].hop_count)) &&
 609       (GNUNET_SCHEDULER_NO_TASK != proof_task))
 610   {
 611     GNUNET_STATISTICS_update (stats,
 612                               "# flood messages not generated (no proof yet)",
 613                               1, GNUNET_NO);
 614     return 0;
 615   }
 616   if (0 == ntohs (size_estimate_messages[idx].header.size))
 617   {
 618     GNUNET_STATISTICS_update (stats,
 619                               "# flood messages not generated (lack of history)",
 620                               1, GNUNET_NO);
 621     return 0;
 622   }
 623   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 624               "In round %llu, sending to `%s' estimate with %u bits\n",
 625               (unsigned long long)
 626               GNUNET_TIME_absolute_ntoh (size_estimate_messages[idx].
 627                                          timestamp).abs_value,
 628               GNUNET_i2s (&peer_entry->id),
 629               (unsigned int) ntohl (size_estimate_messages[idx].matching_bits));
 630   if (ntohl (size_estimate_messages[idx].hop_count) == 0)
 631     GNUNET_STATISTICS_update (stats, "# flood messages started", 1, GNUNET_NO);
 632   GNUNET_STATISTICS_update (stats, "# flood messages transmitted", 1,
 633                             GNUNET_NO);
 634 #if ENABLE_NSE_HISTOGRAM
 635   peer_entry->transmitted_messages++;
 636   peer_entry->last_transmitted_size =
 637       ntohl(size_estimate_messages[idx].matching_bits);
 638 #endif
 639   memcpy (buf, &size_estimate_messages[idx],
 640           sizeof (struct GNUNET_NSE_FloodMessage));
 641   return sizeof (struct GNUNET_NSE_FloodMessage);
 642 }
 643
 644
 645 /**
 646  * Task that triggers a NSE P2P transmission.
 647  *
 648  * @param cls the 'struct NSEPeerEntry'
 649  * @param tc scheduler context
 650  */
 651 static void
 652 transmit_task_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 653 {
 654   struct NSEPeerEntry *peer_entry = cls;
 655
 656   peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK;
 657
 658   GNUNET_assert (NULL == peer_entry->th);
 659   peer_entry->th =
 660       GNUNET_CORE_notify_transmit_ready (coreAPI, GNUNET_NO, NSE_PRIORITY,
 661                                          GNUNET_TIME_UNIT_FOREVER_REL,
 662                                          &peer_entry->id,
 663                                          sizeof (struct
 664                                                  GNUNET_NSE_FloodMessage),
 665                                          &transmit_ready, peer_entry);
 666 }
 667
 668
 669 /**
 670  * We've sent on our flood message or one that we received which was
 671  * validated and closer than ours.  Update the global list of recent
 672  * messages and the average.  Also re-broadcast the message to any
 673  * clients.
 674  */
 675 static void
 676 update_network_size_estimate ()
 677 {
 678   struct GNUNET_NSE_ClientMessage em;
 679
 680   setup_estimate_message (&em);
 681   GNUNET_SERVER_notification_context_broadcast (nc, &em.header, GNUNET_YES);
 682 }
 683
 684
 685 /**
 686  * Setup a flood message in our history array at the given
 687  * slot offset for the given timestamp.
 688  *
 689  * @param slot index to use
 690  * @param ts timestamp to use
 691  */
 692 static void
 693 setup_flood_message (unsigned int slot,
 694                      struct GNUNET_TIME_Absolute ts)
 695 {
 696   struct GNUNET_NSE_FloodMessage *fm;
 697   uint32_t matching_bits;
 698
 699   matching_bits = get_matching_bits (ts, &my_identity);
 700   fm = &size_estimate_messages[slot];
 701   fm->header.size = htons (sizeof (struct GNUNET_NSE_FloodMessage));
 702   fm->header.type = htons (GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD);
 703   fm->hop_count = htonl (0);
 704   fm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_NSE_SEND);
 705   fm->purpose.size =
 706       htonl (sizeof (struct GNUNET_NSE_FloodMessage) -
 707              sizeof (struct GNUNET_MessageHeader) - sizeof (uint32_t) -
 708              sizeof (struct GNUNET_CRYPTO_EccSignature));
 709   fm->matching_bits = htonl (matching_bits);
 710   fm->timestamp = GNUNET_TIME_absolute_hton (ts);
 711   fm->pkey = my_public_key;
 712   fm->proof_of_work = my_proof;
 713   if (nse_work_required > 0)
 714     GNUNET_assert (GNUNET_OK ==
 715                    GNUNET_CRYPTO_ecc_sign (my_private_key, &fm->purpose,
 716                                            &fm->signature));
 717   else
 718     memset (&fm->signature, 0, sizeof (fm->signature));
 719 }
 720
 721
 722 /**
 723  * Schedule transmission for the given peer for the current round based
 724  * on what we know about the desired delay.
 725  *
 726  * @param cls unused
 727  * @param key hash of peer identity
 728  * @param value the 'struct NSEPeerEntry'
 729  * @return GNUNET_OK (continue to iterate)
 730  */
 731 static int
 732 schedule_current_round (void *cls,
 733                         const struct GNUNET_HashCode * key,
 734                         void *value)
 735 {
 736   struct NSEPeerEntry *peer_entry = value;
 737   struct GNUNET_TIME_Relative delay;
 738
 739   if (NULL != peer_entry->th)
 740   {
 741     peer_entry->previous_round = GNUNET_NO;
 742     return GNUNET_OK;
 743   }
 744   if (GNUNET_SCHEDULER_NO_TASK != peer_entry->transmit_task)
 745   {
 746     GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
 747     peer_entry->previous_round = GNUNET_NO;
 748   }
 749 #if ENABLE_NSE_HISTOGRAM
 750   if (peer_entry->received_messages > 1)
 751     GNUNET_STATISTICS_update(stats, "# extra messages",
 752                              peer_entry->received_messages - 1, GNUNET_NO);
 753   peer_entry->transmitted_messages = 0;
 754   peer_entry->last_transmitted_size = 0;
 755   peer_entry->received_messages = 0;
 756 #endif
 757   delay =
 758       get_transmit_delay ((peer_entry->previous_round == GNUNET_NO) ? -1 : 0);
 759   peer_entry->transmit_task =
 760       GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
 761   return GNUNET_OK;
 762 }
 763
 764
 765 /**
 766  * Update our flood message to be sent (and our timestamps).
 767  *
 768  * @param cls unused
 769  * @param tc context for this message
 770  */
 771 static void
 772 update_flood_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 773 {
 774   struct GNUNET_TIME_Relative offset;
 775   unsigned int i;
 776
 777   flood_task = GNUNET_SCHEDULER_NO_TASK;
 778   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 779     return;
 780   offset = GNUNET_TIME_absolute_get_remaining (next_timestamp);
 781   if (0 != offset.rel_value)
 782   {
 783     /* somehow run early, delay more */
 784     flood_task =
 785         GNUNET_SCHEDULER_add_delayed (offset, &update_flood_message, NULL);
 786     return;
 787   }
 788   estimate_index = (estimate_index + 1) % HISTORY_SIZE;
 789   if (estimate_count < HISTORY_SIZE)
 790     estimate_count++;
 791   current_timestamp = next_timestamp;
 792   next_timestamp =
 793       GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
 794   if ((current_timestamp.abs_value ==
 795       GNUNET_TIME_absolute_ntoh (next_message.timestamp).abs_value) &&
 796       (get_matching_bits (current_timestamp, &my_identity) <
 797       ntohl(next_message.matching_bits)))
 798   {
 799     /* we received a message for this round way early, use it! */
 800     size_estimate_messages[estimate_index] = next_message;
 801     size_estimate_messages[estimate_index].hop_count =
 802         htonl (1 + ntohl (next_message.hop_count));
 803   }
 804   else
 805     setup_flood_message (estimate_index, current_timestamp);
 806   next_message.matching_bits = htonl (0);       /* reset for 'next' round */
 807   hop_count_max = 0;
 808   for (i = 0; i < HISTORY_SIZE; i++)
 809     hop_count_max =
 810         GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
 811   GNUNET_CONTAINER_multihashmap_iterate (peers, &schedule_current_round, NULL);
 812   flood_task =
 813       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
 814                                     (next_timestamp), &update_flood_message,
 815                                     NULL);
 816 }
 817
 818
 819 /**
 820  * Count the leading zeroes in hash.
 821  *
 822  * @param hash
 823  * @return the number of leading zero bits.
 824  */
 825 static unsigned int
 826 count_leading_zeroes (const struct GNUNET_HashCode * hash)
 827 {
 828   unsigned int hash_count;
 829
 830   hash_count = 0;
 831   while ((0 == GNUNET_CRYPTO_hash_get_bit (hash, hash_count)))
 832     hash_count++;
 833   return hash_count;
 834 }
 835
 836
 837 /**
 838  * Check whether the given public key
 839  * and integer are a valid proof of work.
 840  *
 841  * @param pkey the public key
 842  * @param val the integer
 843  *
 844  * @return GNUNET_YES if valid, GNUNET_NO if not
 845  */
 846 static int
 847 check_proof_of_work (const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *pkey,
 848                      uint64_t val)
 849 {
 850   char buf[sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
 851            sizeof (val)] GNUNET_ALIGN;
 852   struct GNUNET_HashCode result;
 853
 854   memcpy (buf, &val, sizeof (val));
 855   memcpy (&buf[sizeof (val)], pkey,
 856           sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
 857   pow_hash (buf, sizeof (buf), &result);
 858   return (count_leading_zeroes (&result) >=
 859           nse_work_required) ? GNUNET_YES : GNUNET_NO;
 860 }
 861
 862
 863 /**
 864  * Write our current proof to disk.
 865  */
 866 static void
 867 write_proof ()
 868 {
 869   char *proof;
 870
 871   if (GNUNET_OK !=
 872       GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
 873     return;
 874   if (sizeof (my_proof) !=
 875       GNUNET_DISK_fn_write (proof, &my_proof, sizeof (my_proof),
 876                             GNUNET_DISK_PERM_USER_READ |
 877                             GNUNET_DISK_PERM_USER_WRITE))
 878     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", proof);
 879   GNUNET_free (proof);
 880
 881 }
 882
 883
 884 /**
 885  * Find our proof of work.
 886  *
 887  * @param cls closure (unused)
 888  * @param tc task context
 889  */
 890 static void
 891 find_proof (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 892 {
 893 #define ROUND_SIZE 10
 894   uint64_t counter;
 895   char buf[sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded) +
 896            sizeof (uint64_t)] GNUNET_ALIGN;
 897   struct GNUNET_HashCode result;
 898   unsigned int i;
 899
 900   proof_task = GNUNET_SCHEDULER_NO_TASK;
 901   memcpy (&buf[sizeof (uint64_t)], &my_public_key,
 902           sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
 903   i = 0;
 904   counter = my_proof;
 905   while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
 906   {
 907     memcpy (buf, &counter, sizeof (uint64_t));
 908     pow_hash (buf, sizeof (buf), &result);
 909     if (nse_work_required <= count_leading_zeroes (&result))
 910     {
 911       my_proof = counter;
 912       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work found: %llu!\n",
 913                   (unsigned long long) GNUNET_ntohll (counter));
 914       write_proof ();
 915       setup_flood_message (estimate_index, current_timestamp);
 916       return;
 917     }
 918     counter++;
 919     i++;
 920   }
 921   if (my_proof / (100 * ROUND_SIZE) < counter / (100 * ROUND_SIZE))
 922   {
 923     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Testing proofs currently at %llu\n",
 924                 (unsigned long long) counter);
 925     /* remember progress every 100 rounds */
 926     my_proof = counter;
 927     write_proof ();
 928   }
 929   else
 930   {
 931     my_proof = counter;
 932   }
 933   proof_task =
 934       GNUNET_SCHEDULER_add_delayed_with_priority (proof_find_delay,
 935                                                   GNUNET_SCHEDULER_PRIORITY_IDLE,
 936                                                   &find_proof, NULL);
 937 }
 938
 939
 940 /**
 941  * An incoming flood message has been received which claims
 942  * to have more bits matching than any we know in this time
 943  * period.  Verify the signature and/or proof of work.
 944  *
 945  * @param incoming_flood the message to verify
 946  *
 947  * @return GNUNET_YES if the message is verified
 948  *         GNUNET_NO if the key/signature don't verify
 949  */
 950 static int
 951 verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
 952 {
 953   if (GNUNET_YES !=
 954       check_proof_of_work (&incoming_flood->pkey,
 955                            incoming_flood->proof_of_work))
 956   {
 957     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work invalid: %llu!\n",
 958                 (unsigned long long)
 959                 GNUNET_ntohll (incoming_flood->proof_of_work));
 960     GNUNET_break_op (0);
 961     return GNUNET_NO;
 962   }
 963   if ((nse_work_required > 0) &&
 964       (GNUNET_OK !=
 965        GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
 966                                  &incoming_flood->purpose,
 967                                  &incoming_flood->signature,
 968                                  &incoming_flood->pkey)))
 969   {
 970     GNUNET_break_op (0);
 971     return GNUNET_NO;
 972   }
 973   return GNUNET_YES;
 974 }
 975
 976
 977 /**
 978  * Update transmissions for the given peer for the current round based
 979  * on updated proximity information.
 980  *
 981  * @param cls peer entry to exclude from updates
 982  * @param key hash of peer identity
 983  * @param value the 'struct NSEPeerEntry'
 984  * @return GNUNET_OK (continue to iterate)
 985  */
 986 static int
 987 update_flood_times (void *cls, const struct GNUNET_HashCode * key, void *value)
 988 {
 989   struct NSEPeerEntry *exclude = cls;
 990   struct NSEPeerEntry *peer_entry = value;
 991   struct GNUNET_TIME_Relative delay;
 992
 993   if (NULL != peer_entry->th)
 994     return GNUNET_OK;           /* already active */
 995   if (peer_entry == exclude)
 996     return GNUNET_OK;           /* trigger of the update */
 997   if (peer_entry->previous_round == GNUNET_NO)
 998   {
 999     /* still stuck in previous round, no point to update, check that
1000      * we are active here though... */
1001     if ( (GNUNET_SCHEDULER_NO_TASK == peer_entry->transmit_task) &&
1002          (NULL == peer_entry->th) )
1003     {
1004         GNUNET_break (0);
1005     }
1006     return GNUNET_OK;
1007   }
1008   if (GNUNET_SCHEDULER_NO_TASK != peer_entry->transmit_task)
1009   {
1010     GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
1011     peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK;
1012   }
1013   delay = get_transmit_delay (0);
1014   peer_entry->transmit_task =
1015       GNUNET_SCHEDULER_add_delayed (delay, &transmit_task_cb, peer_entry);
1016   return GNUNET_OK;
1017 }
1018
1019
1020 /**
1021  * Core handler for size estimate flooding messages.
1022  *
1023  * @param cls closure unused
1024  * @param message message
1025  * @param peer peer identity this message is from (ignored)
1026  */
1027 static int
1028 handle_p2p_size_estimate (void *cls, const struct GNUNET_PeerIdentity *peer,
1029                           const struct GNUNET_MessageHeader *message)
1030 {
1031   const struct GNUNET_NSE_FloodMessage *incoming_flood;
1032   struct GNUNET_TIME_Absolute ts;
1033   struct NSEPeerEntry *peer_entry;
1034   uint32_t matching_bits;
1035   unsigned int idx;
1036
1037 #if ENABLE_NSE_HISTOGRAM
1038   {
1039     uint64_t t;
1040
1041     t = GNUNET_TIME_absolute_get().abs_value;
1042     GNUNET_TESTBED_LOGGER_write (lh, &t, sizeof (uint64_t));
1043   }
1044 #endif
1045   incoming_flood = (const struct GNUNET_NSE_FloodMessage *) message;
1046   GNUNET_STATISTICS_update (stats, "# flood messages received", 1, GNUNET_NO);
1047   matching_bits = ntohl (incoming_flood->matching_bits);
1048 #if DEBUG_NSE
1049   {
1050     char origin[5];
1051     char pred[5];
1052     struct GNUNET_PeerIdentity os;
1053
1054     GNUNET_CRYPTO_hash (&incoming_flood->pkey,
1055                         sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
1056                         &os.hashPubKey);
1057     GNUNET_snprintf (origin, sizeof (origin), "%s", GNUNET_i2s (&os));
1058     GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer));
1059     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1060                 "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
1061                 GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
1062                 origin, pred, GNUNET_i2s (&my_identity),
1063                 (unsigned int) matching_bits);
1064   }
1065 #endif
1066
1067   peer_entry = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
1068   if (NULL == peer_entry)
1069   {
1070     GNUNET_break (0);
1071     return GNUNET_OK;
1072   }
1073 #if ENABLE_NSE_HISTOGRAM
1074   peer_entry->received_messages++;
1075   if (peer_entry->transmitted_messages > 0 &&
1076       peer_entry->last_transmitted_size >= matching_bits)
1077     GNUNET_STATISTICS_update(stats, "# cross messages", 1, GNUNET_NO);
1078 #endif
1079
1080   ts = GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp);
1081   if (ts.abs_value == current_timestamp.abs_value)
1082     idx = estimate_index;
1083   else if (ts.abs_value ==
1084            current_timestamp.abs_value - gnunet_nse_interval.rel_value)
1085     idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
1086   else if (ts.abs_value == next_timestamp.abs_value)
1087   {
1088     if (matching_bits <= ntohl (next_message.matching_bits))
1089       return GNUNET_OK;         /* ignore, simply too early/late */
1090     if (GNUNET_YES != verify_message_crypto (incoming_flood))
1091     {
1092       GNUNET_break_op (0);
1093       return GNUNET_OK;
1094     }
1095     next_message = *incoming_flood;
1096     return GNUNET_OK;
1097   }
1098   else
1099   {
1100     GNUNET_STATISTICS_update (stats,
1101                               "# flood messages discarded (clock skew too large)",
1102                               1, GNUNET_NO);
1103     return GNUNET_OK;
1104   }
1105   if (0 == (memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity))))
1106   {
1107     /* send to self, update our own estimate IF this also comes from us! */
1108     if (0 ==
1109         memcmp (&incoming_flood->pkey, &my_public_key, sizeof (my_public_key)))
1110       update_network_size_estimate ();
1111     return GNUNET_OK;
1112   }
1113   if (matching_bits == ntohl (size_estimate_messages[idx].matching_bits))
1114   {
1115     /* Cancel transmission in the other direction, as this peer clearly has
1116        up-to-date information already. Even if we didn't talk to this peer in
1117        the previous round, we should no longer send it stale information as it
1118        told us about the current round! */
1119     peer_entry->previous_round = GNUNET_YES;
1120     if (idx != estimate_index)
1121     {
1122       /* do not transmit information for the previous round to this peer
1123          anymore (but allow current round) */
1124       return GNUNET_OK;
1125     }
1126     /* got up-to-date information for current round, cancel transmission to
1127      * this peer altogether */
1128     if (GNUNET_SCHEDULER_NO_TASK != peer_entry->transmit_task)
1129     {
1130       GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
1131       peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK;
1132     }
1133     if (NULL != peer_entry->th)
1134     {
1135       GNUNET_CORE_notify_transmit_ready_cancel (peer_entry->th);
1136       peer_entry->th = NULL;
1137     }
1138     return GNUNET_OK;
1139   }
1140   if (matching_bits < ntohl (size_estimate_messages[idx].matching_bits))
1141   {
1142     if ((idx < estimate_index) && (peer_entry->previous_round == GNUNET_YES)) {
1143       peer_entry->previous_round = GNUNET_NO;
1144     }
1145     /* push back our result now, that peer is spreading bad information... */
1146     if (NULL == peer_entry->th)
1147     {
1148       if (peer_entry->transmit_task != GNUNET_SCHEDULER_NO_TASK)
1149         GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
1150       peer_entry->transmit_task =
1151           GNUNET_SCHEDULER_add_now (&transmit_task_cb, peer_entry);
1152     }
1153     /* Not closer than our most recent message, no need to do work here */
1154     GNUNET_STATISTICS_update (stats,
1155                               "# flood messages ignored (had closer already)",
1156                               1, GNUNET_NO);
1157     return GNUNET_OK;
1158   }
1159   if (GNUNET_YES != verify_message_crypto (incoming_flood))
1160   {
1161     GNUNET_break_op (0);
1162     return GNUNET_OK;
1163   }
1164   GNUNET_assert (matching_bits >
1165                  ntohl (size_estimate_messages[idx].matching_bits));
1166   /* Cancel transmission in the other direction, as this peer clearly has
1167    * up-to-date information already.
1168    */
1169   peer_entry->previous_round = GNUNET_YES;
1170   if (idx == estimate_index)
1171   {
1172       /* cancel any activity for current round */
1173       if (peer_entry->transmit_task != GNUNET_SCHEDULER_NO_TASK)
1174       {
1175         GNUNET_SCHEDULER_cancel (peer_entry->transmit_task);
1176         peer_entry->transmit_task = GNUNET_SCHEDULER_NO_TASK;
1177       }
1178       if (peer_entry->th != NULL)
1179       {
1180         GNUNET_CORE_notify_transmit_ready_cancel (peer_entry->th);
1181         peer_entry->th = NULL;
1182       }
1183   }
1184   size_estimate_messages[idx] = *incoming_flood;
1185   size_estimate_messages[idx].hop_count =
1186       htonl (ntohl (incoming_flood->hop_count) + 1);
1187   hop_count_max =
1188       GNUNET_MAX (ntohl (incoming_flood->hop_count) + 1, hop_count_max);
1189   GNUNET_STATISTICS_set (stats,
1190                          "# estimated network diameter",
1191                          hop_count_max, GNUNET_NO);
1192
1193   /* have a new, better size estimate, inform clients */
1194   update_network_size_estimate ();
1195
1196   /* flood to rest */
1197   GNUNET_CONTAINER_multihashmap_iterate (peers, &update_flood_times,
1198                                          peer_entry);
1199   return GNUNET_OK;
1200 }
1201
1202
1203
1204 /**
1205  * Method called whenever a peer connects. Sets up the PeerEntry and
1206  * schedules the initial size info transmission to this peer.
1207  *
1208  * @param cls closure
1209  * @param peer peer identity this notification is about
1210  */
1211 static void
1212 handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
1213 {
1214   struct NSEPeerEntry *peer_entry;
1215
1216   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s' connected to us\n",
1217               GNUNET_i2s (peer));
1218   peer_entry = GNUNET_malloc (sizeof (struct NSEPeerEntry));
1219   peer_entry->id = *peer;
1220   GNUNET_assert (GNUNET_OK ==
1221                  GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey,
1222                                                     peer_entry,
1223                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1224   peer_entry->transmit_task =
1225       GNUNET_SCHEDULER_add_delayed (get_transmit_delay (-1), &transmit_task_cb,
1226                                     peer_entry);
1227   GNUNET_STATISTICS_update (stats, "# peers connected", 1, GNUNET_NO);
1228 }
1229
1230
1231 /**
1232  * Method called whenever a peer disconnects. Deletes the PeerEntry and cancels
1233  * any pending transmission requests to that peer.
1234  *
1235  * @param cls closure
1236  * @param peer peer identity this notification is about
1237  */
1238 static void
1239 handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
1240 {
1241   struct NSEPeerEntry *pos;
1242
1243   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%s' disconnected from us\n",
1244               GNUNET_i2s (peer));
1245   pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
1246   if (NULL == pos)
1247   {
1248     GNUNET_break (0);
1249     return;
1250   }
1251   GNUNET_assert (GNUNET_YES ==
1252                  GNUNET_CONTAINER_multihashmap_remove (peers, &peer->hashPubKey,
1253                                                        pos));
1254   if (pos->transmit_task != GNUNET_SCHEDULER_NO_TASK) {
1255     GNUNET_SCHEDULER_cancel (pos->transmit_task);
1256     pos->transmit_task = GNUNET_SCHEDULER_NO_TASK;
1257   }
1258   if (NULL != pos->th)
1259   {
1260     GNUNET_CORE_notify_transmit_ready_cancel (pos->th);
1261     pos->th = NULL;
1262   }
1263   GNUNET_free (pos);
1264   GNUNET_STATISTICS_update (stats, "# peers connected", -1, GNUNET_NO);
1265 }
1266
1267
1268 #if ENABLE_NSE_HISTOGRAM
1269 /**
1270  * Functions of this type are called to notify a successful transmission of the
1271  * message to the logger service
1272  *
1273  * @param cls NULL
1274  * @param size the amount of data sent
1275  */
1276 static void
1277 flush_comp_cb (void *cls, size_t size)
1278 {
1279   GNUNET_TESTBED_LOGGER_disconnect (lh);
1280   lh = NULL;
1281 }
1282 #endif
1283
1284
1285 /**
1286  * Task run during shutdown.
1287  *
1288  * @param cls unused
1289  * @param tc unused
1290  */
1291 static void
1292 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1293 {
1294   if (GNUNET_SCHEDULER_NO_TASK != flood_task)
1295   {
1296     GNUNET_SCHEDULER_cancel (flood_task);
1297     flood_task = GNUNET_SCHEDULER_NO_TASK;
1298   }
1299   if (GNUNET_SCHEDULER_NO_TASK != proof_task)
1300   {
1301     GNUNET_SCHEDULER_cancel (proof_task);
1302     proof_task = GNUNET_SCHEDULER_NO_TASK;
1303     write_proof ();             /* remember progress */
1304   }
1305   if (NULL != nc)
1306   {
1307     GNUNET_SERVER_notification_context_destroy (nc);
1308     nc = NULL;
1309   }
1310   if (NULL != coreAPI)
1311   {
1312     GNUNET_CORE_disconnect (coreAPI);
1313     coreAPI = NULL;
1314   }
1315   if (NULL != stats)
1316   {
1317     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
1318     stats = NULL;
1319   }
1320   if (NULL != peers)
1321   {
1322     GNUNET_CONTAINER_multihashmap_destroy (peers);
1323     peers = NULL;
1324   }
1325   if (NULL != my_private_key)
1326   {
1327     GNUNET_CRYPTO_ecc_key_free (my_private_key);
1328     my_private_key = NULL;
1329   }
1330 #if ENABLE_NSE_HISTOGRAM
1331   struct GNUNET_TIME_Relative timeout;
1332   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
1333   GNUNET_TESTBED_LOGGER_flush (lh, timeout, &flush_comp_cb, NULL);
1334 #endif
1335 }
1336
1337
1338 /**
1339  * Called on core init/fail.
1340  *
1341  * @param cls service closure
1342  * @param server handle to the server for this service
1343  * @param identity the public identity of this peer
1344  */
1345 static void
1346 core_init (void *cls, struct GNUNET_CORE_Handle *server,
1347            const struct GNUNET_PeerIdentity *identity)
1348 {
1349   struct GNUNET_TIME_Absolute now;
1350   struct GNUNET_TIME_Absolute prev_time;
1351
1352   if (NULL == server)
1353   {
1354     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to core FAILED!\n");
1355     GNUNET_SCHEDULER_shutdown ();
1356     return;
1357   }
1358   GNUNET_assert (0 ==
1359                  memcmp (&my_identity, identity,
1360                          sizeof (struct GNUNET_PeerIdentity)));
1361   now = GNUNET_TIME_absolute_get ();
1362   current_timestamp.abs_value =
1363       (now.abs_value / gnunet_nse_interval.rel_value) *
1364       gnunet_nse_interval.rel_value;
1365   next_timestamp =
1366       GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
1367   estimate_index = HISTORY_SIZE - 1;
1368   estimate_count = 0;
1369   if (GNUNET_YES == check_proof_of_work (&my_public_key, my_proof))
1370   {
1371     int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
1372     prev_time.abs_value =
1373         current_timestamp.abs_value - gnunet_nse_interval.rel_value;
1374     setup_flood_message (idx, prev_time);
1375     setup_flood_message (estimate_index, current_timestamp);
1376     estimate_count++;
1377   }
1378   flood_task =
1379       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
1380                                     (next_timestamp), &update_flood_message,
1381                                     NULL);
1382 }
1383
1384
1385 /**
1386  * Handle network size estimate clients.
1387  *
1388  * @param cls closure
1389  * @param server the initialized server
1390  * @param c configuration to use
1391  */
1392 static void
1393 run (void *cls,
1394      struct GNUNET_SERVER_Handle *server,
1395      const struct GNUNET_CONFIGURATION_Handle *c)
1396 {
1397   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
1398     {&handle_start_message, NULL, GNUNET_MESSAGE_TYPE_NSE_START,
1399      sizeof (struct GNUNET_MessageHeader)},
1400     {NULL, NULL, 0, 0}
1401   };
1402   static const struct GNUNET_CORE_MessageHandler core_handlers[] = {
1403     {&handle_p2p_size_estimate, GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
1404      sizeof (struct GNUNET_NSE_FloodMessage)},
1405     {NULL, 0, 0}
1406   };
1407   char *proof;
1408   char *keyfile;
1409   struct GNUNET_CRYPTO_EccPrivateKey *pk;
1410
1411   cfg = c;
1412   srv = server;
1413   if ((GNUNET_OK !=
1414        GNUNET_CONFIGURATION_get_value_time (cfg, "NSE", "INTERVAL",
1415                                             &gnunet_nse_interval)) ||
1416       (GNUNET_OK !=
1417        GNUNET_CONFIGURATION_get_value_time (cfg, "NSE", "WORKDELAY",
1418                                             &proof_find_delay)) ||
1419       (GNUNET_OK !=
1420        GNUNET_CONFIGURATION_get_value_number (cfg, "NSE", "WORKBITS",
1421                                               &nse_work_required)))
1422   {
1423     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1424                 _
1425                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
1426                 "NSE", "interval/workdelay/workbits");
1427     GNUNET_SCHEDULER_shutdown ();
1428     return;
1429   }
1430   if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
1431   {
1432     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1433                 _("Invalid work requirement for NSE service. Exiting.\n"));
1434     GNUNET_SCHEDULER_shutdown ();
1435     return;
1436   }
1437   if (GNUNET_OK !=
1438       GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
1439                                                &keyfile))
1440   {
1441     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1442                 _
1443                 ("%s service is lacking key configuration settings (%s).  Exiting.\n"),
1444                 "NSE", "peer/privatekey");
1445     GNUNET_SCHEDULER_shutdown ();
1446     return;
1447   }
1448 #if ENABLE_NSE_HISTOGRAM
1449   if (NULL == (lh = GNUNET_TESTBED_LOGGER_connect (cfg)))
1450   {
1451     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1452                 "Cannot connect to the testbed logger.  Exiting.\n");
1453     GNUNET_SCHEDULER_shutdown ();
1454     return;
1455   }
1456 #endif
1457
1458   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
1459                                 NULL);
1460   pk = GNUNET_CRYPTO_ecc_key_create_from_file (keyfile);
1461   GNUNET_free (keyfile);
1462   GNUNET_assert (NULL != pk);
1463   my_private_key = pk;
1464   GNUNET_CRYPTO_ecc_key_get_public (my_private_key, &my_public_key);
1465   GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
1466                       &my_identity.hashPubKey);
1467   if (GNUNET_OK !=
1468       GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
1469   {
1470     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1471                 _
1472                 ("NSE service is lacking key configuration settings.  Exiting.\n"));
1473     GNUNET_CRYPTO_ecc_key_free (my_private_key);
1474     my_private_key = NULL;
1475     GNUNET_SCHEDULER_shutdown ();
1476     return;
1477   }
1478   if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
1479       (sizeof (my_proof) !=
1480        GNUNET_DISK_fn_read (proof, &my_proof, sizeof (my_proof))))
1481     my_proof = 0;
1482   GNUNET_free (proof);
1483   proof_task =
1484       GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
1485                                           &find_proof, NULL);
1486
1487   peers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
1488   GNUNET_SERVER_add_handlers (srv, handlers);
1489   nc = GNUNET_SERVER_notification_context_create (srv, 1);
1490   /* Connect to core service and register core handlers */
1491   coreAPI = GNUNET_CORE_connect (cfg,   /* Main configuration */
1492                                  NULL,       /* Closure passed to functions */
1493                                  &core_init,    /* Call core_init once connected */
1494                                  &handle_core_connect,  /* Handle connects */
1495                                  &handle_core_disconnect,       /* Handle disconnects */
1496                                  NULL,  /* Don't want notified about all incoming messages */
1497                                  GNUNET_NO,     /* For header only inbound notification */
1498                                  NULL,  /* Don't want notified about all outbound messages */
1499                                  GNUNET_NO,     /* For header only outbound notification */
1500                                  core_handlers);        /* Register these handlers */
1501   if (NULL == coreAPI)
1502   {
1503     GNUNET_SCHEDULER_shutdown ();
1504     return;
1505   }
1506   stats = GNUNET_STATISTICS_create ("nse", cfg);
1507 }
1508
1509
1510 /**
1511  * The main function for the network size estimation service.
1512  *
1513  * @param argc number of arguments from the command line
1514  * @param argv command line arguments
1515  * @return 0 ok, 1 on error
1516  */
1517 int
1518 main (int argc, char *const *argv)
1519 {
1520   return (GNUNET_OK ==
1521           GNUNET_SERVICE_run (argc, argv, "nse", GNUNET_SERVICE_OPTION_NONE,
1522                               &run, NULL)) ? 0 : 1;
1523 }
1524
1525
1526 #ifdef LINUX
1527 #include <malloc.h>
1528
1529 /**
1530  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
1531  */
1532 void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
1533 {
1534   mallopt (M_TRIM_THRESHOLD, 4 * 1024);
1535   mallopt (M_TOP_PAD, 1 * 1024);
1536   malloc_trim (0);
1537 }
1538 #endif
1539
1540
1541
1542 /* end of gnunet-service-nse.c */