src/core/gnunet-service-core.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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 2, 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 core/gnunet-service-core.c
  23  * @brief high-level P2P messaging
  24  * @author Christian Grothoff
  25  *
  26  * Considerations for later:
  27  * - check that hostkey used by transport (for HELLOs) is the
  28  *   same as the hostkey that we are using!
  29  * - add code to send PINGs if we are about to time-out otherwise
  30  * - optimize lookup (many O(n) list traversals
  31  *   could ideally be changed to O(1) hash map lookups)
  32  */
  33 #include "platform.h"
  34 #include "gnunet_constants.h"
  35 #include "gnunet_util_lib.h"
  36 #include "gnunet_hello_lib.h"
  37 #include "gnunet_peerinfo_service.h"
  38 #include "gnunet_protocols.h"
  39 #include "gnunet_signatures.h"
  40 #include "gnunet_statistics_service.h"
  41 #include "gnunet_transport_service.h"
  42 #include "core.h"
  43
  44
  45 #define DEBUG_HANDSHAKE GNUNET_NO
  46
  47 #define DEBUG_CORE_QUOTA GNUNET_NO
  48
  49 /**
  50  * Receive and send buffer windows grow over time.  For
  51  * how long can 'unused' bandwidth accumulate before we
  52  * need to cap it?  (specified in seconds).
  53  */
  54 #define MAX_WINDOW_TIME_S (5 * 60)
  55
  56 /**
  57  * How many messages do we queue up at most for optional
  58  * notifications to a client?  (this can cause notifications
  59  * about outgoing messages to be dropped).
  60  */
  61 #define MAX_NOTIFY_QUEUE 1024
  62
  63 /**
  64  * Minimum bandwidth (out) to assign to any connected peer.
  65  * Should be rather low; values larger than DEFAULT_BW_IN_OUT make no
  66  * sense.
  67  */
  68 #define MIN_BANDWIDTH_PER_PEER GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT
  69
  70 /**
  71  * After how much time past the "official" expiration time do
  72  * we discard messages?  Should not be zero since we may
  73  * intentionally defer transmission until close to the deadline
  74  * and then may be slightly past the deadline due to inaccuracy
  75  * in sleep and our own CPU consumption.
  76  */
  77 #define PAST_EXPIRATION_DISCARD_TIME GNUNET_TIME_UNIT_SECONDS
  78
  79 /**
  80  * What is the maximum delay for a SET_KEY message?
  81  */
  82 #define MAX_SET_KEY_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
  83
  84 /**
  85  * How long do we wait for SET_KEY confirmation initially?
  86  */
  87 #define INITIAL_SET_KEY_RETRY_FREQUENCY GNUNET_TIME_relative_multiply (MAX_SET_KEY_DELAY, 1)
  88
  89 /**
  90  * What is the maximum delay for a PING message?
  91  */
  92 #define MAX_PING_DELAY GNUNET_TIME_relative_multiply (MAX_SET_KEY_DELAY, 2)
  93
  94 /**
  95  * What is the maximum delay for a PONG message?
  96  */
  97 #define MAX_PONG_DELAY GNUNET_TIME_relative_multiply (MAX_PING_DELAY, 2)
  98
  99 /**
 100  * What is the minimum frequency for a PING message?
 101  */
 102 #define MIN_PING_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 103
 104 /**
 105  * How often do we recalculate bandwidth quotas?
 106  */
 107 #define QUOTA_UPDATE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 108
 109 /**
 110  * What is the priority for a SET_KEY message?
 111  */
 112 #define SET_KEY_PRIORITY 0xFFFFFF
 113
 114 /**
 115  * What is the priority for a PING message?
 116  */
 117 #define PING_PRIORITY 0xFFFFFF
 118
 119 /**
 120  * What is the priority for a PONG message?
 121  */
 122 #define PONG_PRIORITY 0xFFFFFF
 123
 124 /**
 125  * How many messages do we queue per peer at most?  Must be at
 126  * least two.
 127  */
 128 #define MAX_PEER_QUEUE_SIZE 16
 129
 130 /**
 131  * How many non-mandatory messages do we queue per client at most?
 132  */
 133 #define MAX_CLIENT_QUEUE_SIZE 32
 134
 135 /**
 136  * What is the maximum age of a message for us to consider
 137  * processing it?  Note that this looks at the timestamp used
 138  * by the other peer, so clock skew between machines does
 139  * come into play here.  So this should be picked high enough
 140  * so that a little bit of clock skew does not prevent peers
 141  * from connecting to us.
 142  */
 143 #define MAX_MESSAGE_AGE GNUNET_TIME_UNIT_DAYS
 144
 145
 146 /**
 147  * State machine for our P2P encryption handshake.  Everyone starts in
 148  * "DOWN", if we receive the other peer's key (other peer initiated)
 149  * we start in state RECEIVED (since we will immediately send our
 150  * own); otherwise we start in SENT.  If we get back a PONG from
 151  * within either state, we move up to CONFIRMED (the PONG will always
 152  * be sent back encrypted with the key we sent to the other peer).
 153  */
 154 enum PeerStateMachine
 155 {
 156   PEER_STATE_DOWN,
 157   PEER_STATE_KEY_SENT,
 158   PEER_STATE_KEY_RECEIVED,
 159   PEER_STATE_KEY_CONFIRMED
 160 };
 161
 162
 163 /**
 164  * Number of bytes (at the beginning) of "struct EncryptedMessage"
 165  * that are NOT encrypted.
 166  */
 167 #define ENCRYPTED_HEADER_SIZE (sizeof(struct GNUNET_MessageHeader) + sizeof(uint32_t))
 168
 169
 170 /**
 171  * Encapsulation for encrypted messages exchanged between
 172  * peers.  Followed by the actual encrypted data.
 173  */
 174 struct EncryptedMessage
 175 {
 176   /**
 177    * Message type is either CORE_ENCRYPTED_MESSAGE.
 178    */
 179   struct GNUNET_MessageHeader header;
 180
 181   /**
 182    * Random value used for IV generation.  ENCRYPTED_HEADER_SIZE must
 183    * be set to the offset of the *next* field.
 184    */
 185   uint32_t iv_seed GNUNET_PACKED;
 186
 187   /**
 188    * Hash of the plaintext (starting at 'sequence_number'), used to
 189    * verify message integrity.  Everything after this hash (including
 190    * this hash itself) will be encrypted.
 191    */
 192   GNUNET_HashCode plaintext_hash;
 193
 194   /**
 195    * Sequence number, in network byte order.  This field
 196    * must be the first encrypted/decrypted field and the
 197    * first byte that is hashed for the plaintext hash.
 198    */
 199   uint32_t sequence_number GNUNET_PACKED;
 200
 201   /**
 202    * Desired bandwidth (how much we should send to this peer / how
 203    * much is the sender willing to receive)?
 204    */
 205   struct GNUNET_BANDWIDTH_Value32NBO inbound_bw_limit;
 206
 207   /**
 208    * Timestamp.  Used to prevent reply of ancient messages
 209    * (recent messages are caught with the sequence number).
 210    */
 211   struct GNUNET_TIME_AbsoluteNBO timestamp;
 212
 213 };
 214
 215
 216 /**
 217  * We're sending an (encrypted) PING to the other peer to check if he
 218  * can decrypt.  The other peer should respond with a PONG with the
 219  * same content, except this time encrypted with the receiver's key.
 220  */
 221 struct PingMessage
 222 {
 223   /**
 224    * Message type is CORE_PING.
 225    */
 226   struct GNUNET_MessageHeader header;
 227
 228   /**
 229    * Random number chosen to make reply harder.
 230    */
 231   uint32_t challenge GNUNET_PACKED;
 232
 233   /**
 234    * Intended target of the PING, used primarily to check
 235    * that decryption actually worked.
 236    */
 237   struct GNUNET_PeerIdentity target;
 238 };
 239
 240
 241
 242 /**
 243  * Response to a PING.  Includes data from the original PING
 244  * plus initial bandwidth quota information.
 245  */
 246 struct PongMessage
 247 {
 248   /**
 249    * Message type is CORE_PONG.
 250    */
 251   struct GNUNET_MessageHeader header;
 252
 253   /**
 254    * Random number proochosen to make reply harder.  Must be
 255    * first field after header (this is where we start to encrypt!).
 256    */
 257   uint32_t challenge GNUNET_PACKED;
 258
 259   /**
 260    * Must be zero.
 261    */
 262   uint32_t reserved GNUNET_PACKED;
 263
 264   /**
 265    * Desired bandwidth (how much we should send to this
 266    * peer / how much is the sender willing to receive).
 267    */
 268   struct GNUNET_BANDWIDTH_Value32NBO inbound_bw_limit;
 269
 270   /**
 271    * Intended target of the PING, used primarily to check
 272    * that decryption actually worked.
 273    */
 274   struct GNUNET_PeerIdentity target;
 275 };
 276
 277
 278 /**
 279  * Message transmitted to set (or update) a session key.
 280  */
 281 struct SetKeyMessage
 282 {
 283
 284   /**
 285    * Message type is either CORE_SET_KEY.
 286    */
 287   struct GNUNET_MessageHeader header;
 288
 289   /**
 290    * Status of the sender (should be in "enum PeerStateMachine"), nbo.
 291    */
 292   int32_t sender_status GNUNET_PACKED;
 293
 294   /**
 295    * Purpose of the signature, will be
 296    * GNUNET_SIGNATURE_PURPOSE_SET_KEY.
 297    */
 298   struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
 299
 300   /**
 301    * At what time was this key created?
 302    */
 303   struct GNUNET_TIME_AbsoluteNBO creation_time;
 304
 305   /**
 306    * The encrypted session key.
 307    */
 308   struct GNUNET_CRYPTO_RsaEncryptedData encrypted_key;
 309
 310   /**
 311    * Who is the intended recipient?
 312    */
 313   struct GNUNET_PeerIdentity target;
 314
 315   /**
 316    * Signature of the stuff above (starting at purpose).
 317    */
 318   struct GNUNET_CRYPTO_RsaSignature signature;
 319
 320 };
 321
 322
 323 /**
 324  * Message waiting for transmission. This struct
 325  * is followed by the actual content of the message.
 326  */
 327 struct MessageEntry
 328 {
 329
 330   /**
 331    * We keep messages in a doubly linked list.
 332    */
 333   struct MessageEntry *next;
 334
 335   /**
 336    * We keep messages in a doubly linked list.
 337    */
 338   struct MessageEntry *prev;
 339
 340   /**
 341    * By when are we supposed to transmit this message?
 342    */
 343   struct GNUNET_TIME_Absolute deadline;
 344
 345   /**
 346    * By when are we supposed to transmit this message (after
 347    * giving slack)?
 348    */
 349   struct GNUNET_TIME_Absolute slack_deadline;
 350
 351   /**
 352    * How important is this message to us?
 353    */
 354   unsigned int priority;
 355
 356   /**
 357    * If this is a SET_KEY message, what was our connection status when this
 358    * message was queued?
 359    */
 360   enum PeerStateMachine sender_status;
 361
 362   /**
 363    * Is this a SET_KEY message?
 364    */
 365   int is_setkey;
 366
 367   /**
 368    * How long is the message? (number of bytes following
 369    * the "struct MessageEntry", but not including the
 370    * size of "struct MessageEntry" itself!)
 371    */
 372   uint16_t size;
 373
 374   /**
 375    * Was this message selected for transmission in the
 376    * current round? GNUNET_YES or GNUNET_NO.
 377    */
 378   int8_t do_transmit;
 379
 380   /**
 381    * Did we give this message some slack (delayed sending) previously
 382    * (and hence should not give it any more slack)? GNUNET_YES or
 383    * GNUNET_NO.
 384    */
 385   int8_t got_slack;
 386
 387 };
 388
 389
 390 struct Neighbour
 391 {
 392   /**
 393    * We keep neighbours in a linked list (for now).
 394    */
 395   struct Neighbour *next;
 396
 397   /**
 398    * Unencrypted messages destined for this peer.
 399    */
 400   struct MessageEntry *messages;
 401
 402   /**
 403    * Head of the batched, encrypted message queue (already ordered,
 404    * transmit starting with the head).
 405    */
 406   struct MessageEntry *encrypted_head;
 407
 408   /**
 409    * Tail of the batched, encrypted message queue (already ordered,
 410    * append new messages to tail)
 411    */
 412   struct MessageEntry *encrypted_tail;
 413
 414   /**
 415    * Handle for pending requests for transmission to this peer
 416    * with the transport service.  NULL if no request is pending.
 417    */
 418   struct GNUNET_TRANSPORT_TransmitHandle *th;
 419
 420   /**
 421    * Public key of the neighbour, NULL if we don't have it yet.
 422    */
 423   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key;
 424
 425   /**
 426    * We received a PING message before we got the "public_key"
 427    * (or the SET_KEY).  We keep it here until we have a key
 428    * to decrypt it.  NULL if no PING is pending.
 429    */
 430   struct PingMessage *pending_ping;
 431
 432   /**
 433    * We received a PONG message before we got the "public_key"
 434    * (or the SET_KEY).  We keep it here until we have a key
 435    * to decrypt it.  NULL if no PONG is pending.
 436    */
 437   struct PongMessage *pending_pong;
 438
 439   /**
 440    * Non-NULL if we are currently looking up HELLOs for this peer.
 441    * for this peer.
 442    */
 443   struct GNUNET_PEERINFO_IteratorContext *pitr;
 444
 445   /**
 446    * SetKeyMessage to transmit, NULL if we are not currently trying
 447    * to send one.
 448    */
 449   struct SetKeyMessage *skm;
 450
 451   /**
 452    * Identity of the neighbour.
 453    */
 454   struct GNUNET_PeerIdentity peer;
 455
 456   /**
 457    * Key we use to encrypt our messages for the other peer
 458    * (initialized by us when we do the handshake).
 459    */
 460   struct GNUNET_CRYPTO_AesSessionKey encrypt_key;
 461
 462   /**
 463    * Key we use to decrypt messages from the other peer
 464    * (given to us by the other peer during the handshake).
 465    */
 466   struct GNUNET_CRYPTO_AesSessionKey decrypt_key;
 467
 468   /**
 469    * ID of task used for re-trying plaintext scheduling.
 470    */
 471   GNUNET_SCHEDULER_TaskIdentifier retry_plaintext_task;
 472
 473   /**
 474    * ID of task used for re-trying SET_KEY and PING message.
 475    */
 476   GNUNET_SCHEDULER_TaskIdentifier retry_set_key_task;
 477
 478   /**
 479    * ID of task used for updating bandwidth quota for this neighbour.
 480    */
 481   GNUNET_SCHEDULER_TaskIdentifier quota_update_task;
 482
 483   /**
 484    * ID of task used for sending keep-alive pings.
 485    */
 486   GNUNET_SCHEDULER_TaskIdentifier keep_alive_task;
 487
 488   /**
 489    * ID of task used for cleaning up dead neighbour entries.
 490    */
 491   GNUNET_SCHEDULER_TaskIdentifier dead_clean_task;
 492
 493   /**
 494    * At what time did we generate our encryption key?
 495    */
 496   struct GNUNET_TIME_Absolute encrypt_key_created;
 497
 498   /**
 499    * At what time did the other peer generate the decryption key?
 500    */
 501   struct GNUNET_TIME_Absolute decrypt_key_created;
 502
 503   /**
 504    * At what time did we initially establish (as in, complete session
 505    * key handshake) this connection?  Should be zero if status != KEY_CONFIRMED.
 506    */
 507   struct GNUNET_TIME_Absolute time_established;
 508
 509   /**
 510    * At what time did we last receive an encrypted message from the
 511    * other peer?  Should be zero if status != KEY_CONFIRMED.
 512    */
 513   struct GNUNET_TIME_Absolute last_activity;
 514
 515   /**
 516    * Last latency observed from this peer.
 517    */
 518   struct GNUNET_TIME_Relative last_latency;
 519
 520   /**
 521    * At what frequency are we currently re-trying SET_KEY messages?
 522    */
 523   struct GNUNET_TIME_Relative set_key_retry_frequency;
 524
 525   /**
 526    * Tracking bandwidth for sending to this peer.
 527    */
 528   struct GNUNET_BANDWIDTH_Tracker available_send_window;
 529
 530   /**
 531    * Tracking bandwidth for receiving from this peer.
 532    */
 533   struct GNUNET_BANDWIDTH_Tracker available_recv_window;
 534
 535   /**
 536    * How valueable were the messages of this peer recently?
 537    */
 538   unsigned long long current_preference;
 539
 540   /**
 541    * Bit map indicating which of the 32 sequence numbers before the last
 542    * were received (good for accepting out-of-order packets and
 543    * estimating reliability of the connection)
 544    */
 545   unsigned int last_packets_bitmap;
 546
 547   /**
 548    * last sequence number received on this connection (highest)
 549    */
 550   uint32_t last_sequence_number_received;
 551
 552   /**
 553    * last sequence number transmitted
 554    */
 555   uint32_t last_sequence_number_sent;
 556
 557   /**
 558    * Available bandwidth in for this peer (current target).
 559    */
 560   struct GNUNET_BANDWIDTH_Value32NBO bw_in;
 561
 562   /**
 563    * Available bandwidth out for this peer (current target).
 564    */
 565   struct GNUNET_BANDWIDTH_Value32NBO bw_out;
 566
 567   /**
 568    * Internal bandwidth limit set for this peer (initially typically
 569    * set to "-1").  Actual "bw_out" is MIN of
 570    * "bpm_out_internal_limit" and "bw_out_external_limit".
 571    */
 572   struct GNUNET_BANDWIDTH_Value32NBO bw_out_internal_limit;
 573
 574   /**
 575    * External bandwidth limit set for this peer by the
 576    * peer that we are communicating with.  "bw_out" is MIN of
 577    * "bw_out_internal_limit" and "bw_out_external_limit".
 578    */
 579   struct GNUNET_BANDWIDTH_Value32NBO bw_out_external_limit;
 580
 581   /**
 582    * What was our PING challenge number (for this peer)?
 583    */
 584   uint32_t ping_challenge;
 585
 586   /**
 587    * What was the last distance to this peer as reported by the transports?
 588    */
 589   uint32_t last_distance;
 590
 591   /**
 592    * What is our connection status?
 593    */
 594   enum PeerStateMachine status;
 595
 596   /**
 597    * Are we currently connected to this neighbour?
 598    */
 599   int is_connected;
 600
 601 };
 602
 603
 604 /**
 605  * Data structure for each client connected to the core service.
 606  */
 607 struct Client
 608 {
 609   /**
 610    * Clients are kept in a linked list.
 611    */
 612   struct Client *next;
 613
 614   /**
 615    * Handle for the client with the server API.
 616    */
 617   struct GNUNET_SERVER_Client *client_handle;
 618
 619   /**
 620    * Array of the types of messages this peer cares
 621    * about (with "tcnt" entries).  Allocated as part
 622    * of this client struct, do not free!
 623    */
 624   const uint16_t *types;
 625
 626   /**
 627    * Options for messages this client cares about,
 628    * see GNUNET_CORE_OPTION_ values.
 629    */
 630   uint32_t options;
 631
 632   /**
 633    * Number of types of incoming messages this client
 634    * specifically cares about.  Size of the "types" array.
 635    */
 636   unsigned int tcnt;
 637
 638 };
 639
 640
 641 /**
 642  * Our public key.
 643  */
 644 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
 645
 646 /**
 647  * Our identity.
 648  */
 649 static struct GNUNET_PeerIdentity my_identity;
 650
 651 /**
 652  * Our private key.
 653  */
 654 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
 655
 656 /**
 657  * Our scheduler.
 658  */
 659 struct GNUNET_SCHEDULER_Handle *sched;
 660
 661 /**
 662  * Handle to peerinfo service.
 663  */
 664 static struct GNUNET_PEERINFO_Handle *peerinfo;
 665
 666 /**
 667  * Our configuration.
 668  */
 669 const struct GNUNET_CONFIGURATION_Handle *cfg;
 670
 671 /**
 672  * Our server.
 673  */
 674 static struct GNUNET_SERVER_Handle *server;
 675
 676 /**
 677  * Transport service.
 678  */
 679 static struct GNUNET_TRANSPORT_Handle *transport;
 680
 681 /**
 682  * Linked list of our clients.
 683  */
 684 static struct Client *clients;
 685
 686 /**
 687  * Context for notifications we need to send to our clients.
 688  */
 689 static struct GNUNET_SERVER_NotificationContext *notifier;
 690
 691 /**
 692  * We keep neighbours in a linked list (for now).
 693  */
 694 static struct Neighbour *neighbours;
 695
 696 /**
 697  * For creating statistics.
 698  */
 699 static struct GNUNET_STATISTICS_Handle *stats;
 700
 701 /**
 702  * Sum of all preferences among all neighbours.
 703  */
 704 static unsigned long long preference_sum;
 705
 706 /**
 707  * Total number of neighbours we have.
 708  */
 709 static unsigned int neighbour_count;
 710
 711 /**
 712  * How much inbound bandwidth are we supposed to be using per second?
 713  * FIXME: this value is not used!
 714  */
 715 static unsigned long long bandwidth_target_in_bps;
 716
 717 /**
 718  * How much outbound bandwidth are we supposed to be using per second?
 719  */
 720 static unsigned long long bandwidth_target_out_bps;
 721
 722
 723
 724 /**
 725  * A preference value for a neighbour was update.  Update
 726  * the preference sum accordingly.
 727  *
 728  * @param inc how much was a preference value increased?
 729  */
 730 static void
 731 update_preference_sum (unsigned long long inc)
 732 {
 733   struct Neighbour *n;
 734   unsigned long long os;
 735
 736   os = preference_sum;
 737   preference_sum += inc;
 738   if (preference_sum >= os)
 739     return; /* done! */
 740   /* overflow! compensate by cutting all values in half! */
 741   preference_sum = 0;
 742   n = neighbours;
 743   while (n != NULL)
 744     {
 745       n->current_preference /= 2;
 746       preference_sum += n->current_preference;
 747       n = n->next;
 748     }
 749   GNUNET_STATISTICS_set (stats, gettext_noop ("# total peer preference"), preference_sum, GNUNET_NO);
 750 }
 751
 752
 753 /**
 754  * Find the entry for the given neighbour.
 755  *
 756  * @param peer identity of the neighbour
 757  * @return NULL if we are not connected, otherwise the
 758  *         neighbour's entry.
 759  */
 760 static struct Neighbour *
 761 find_neighbour (const struct GNUNET_PeerIdentity *peer)
 762 {
 763   struct Neighbour *ret;
 764
 765   ret = neighbours;
 766   while ((ret != NULL) &&
 767          (0 != memcmp (&ret->peer,
 768                        peer, sizeof (struct GNUNET_PeerIdentity))))
 769     ret = ret->next;
 770   return ret;
 771 }
 772
 773
 774 /**
 775  * Send a message to one of our clients.
 776  *
 777  * @param client target for the message
 778  * @param msg message to transmit
 779  * @param can_drop could this message be dropped if the
 780  *        client's queue is getting too large?
 781  */
 782 static void
 783 send_to_client (struct Client *client,
 784                 const struct GNUNET_MessageHeader *msg,
 785                 int can_drop)
 786 {
 787 #if DEBUG_CORE_CLIENT
 788   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 789               "Preparing to send %u bytes of message of type %u to client.\n",
 790               (unsigned int) ntohs (msg->size),
 791               (unsigned int) ntohs (msg->type));
 792 #endif
 793   GNUNET_SERVER_notification_context_unicast (notifier,
 794                                               client->client_handle,
 795                                               msg,
 796                                               can_drop);
 797 }
 798
 799
 800 /**
 801  * Send a message to all of our current clients that have
 802  * the right options set.
 803  *
 804  * @param msg message to multicast
 805  * @param can_drop can this message be discarded if the queue is too long
 806  * @param options mask to use
 807  */
 808 static void
 809 send_to_all_clients (const struct GNUNET_MessageHeader *msg,
 810                      int can_drop,
 811                      int options)
 812 {
 813   struct Client *c;
 814
 815   c = clients;
 816   while (c != NULL)
 817     {
 818       if (0 != (c->options & options))
 819         {
 820 #if DEBUG_CORE_CLIENT
 821           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 822                       "Sending message of type %u to client.\n",
 823                       (unsigned int) ntohs (msg->type));
 824 #endif
 825           send_to_client (c, msg, can_drop);
 826         }
 827       c = c->next;
 828     }
 829 }
 830
 831
 832 /**
 833  * Handle CORE_INIT request.
 834  */
 835 static void
 836 handle_client_init (void *cls,
 837                     struct GNUNET_SERVER_Client *client,
 838                     const struct GNUNET_MessageHeader *message)
 839 {
 840   const struct InitMessage *im;
 841   struct InitReplyMessage irm;
 842   struct Client *c;
 843   uint16_t msize;
 844   const uint16_t *types;
 845   uint16_t *wtypes;
 846   struct Neighbour *n;
 847   struct ConnectNotifyMessage cnm;
 848   unsigned int i;
 849
 850 #if DEBUG_CORE_CLIENT
 851   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 852               "Client connecting to core service with `%s' message\n",
 853               "INIT");
 854 #endif
 855   /* check that we don't have an entry already */
 856   c = clients;
 857   while (c != NULL)
 858     {
 859       if (client == c->client_handle)
 860         {
 861           GNUNET_break (0);
 862           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 863           return;
 864         }
 865       c = c->next;
 866     }
 867   msize = ntohs (message->size);
 868   if (msize < sizeof (struct InitMessage))
 869     {
 870       GNUNET_break (0);
 871       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 872       return;
 873     }
 874   GNUNET_SERVER_notification_context_add (notifier, client);
 875   im = (const struct InitMessage *) message;
 876   types = (const uint16_t *) &im[1];
 877   msize -= sizeof (struct InitMessage);
 878   c = GNUNET_malloc (sizeof (struct Client) + msize);
 879   c->client_handle = client;
 880   c->next = clients;
 881   clients = c;
 882   c->tcnt = msize / sizeof (uint16_t);
 883   c->types = (const uint16_t *) &c[1];
 884   wtypes = (uint16_t *) &c[1];
 885   for (i=0;i<c->tcnt;i++)
 886     wtypes[i] = ntohs (types[i]);
 887   c->options = ntohl (im->options);
 888 #if DEBUG_CORE_CLIENT
 889   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 890               "Client %p is interested in %u message types\n",
 891               c,
 892               (unsigned int) c->tcnt);
 893 #endif
 894   /* send init reply message */
 895   irm.header.size = htons (sizeof (struct InitReplyMessage));
 896   irm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY);
 897   irm.reserved = htonl (0);
 898   memcpy (&irm.publicKey,
 899           &my_public_key,
 900           sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
 901 #if DEBUG_CORE_CLIENT
 902   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 903               "Sending `%s' message to client.\n", "INIT_REPLY");
 904 #endif
 905   send_to_client (c, &irm.header, GNUNET_NO);
 906   if (0 != (c->options & GNUNET_CORE_OPTION_SEND_CONNECT))
 907     {
 908       /* notify new client about existing neighbours */
 909       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
 910       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
 911       n = neighbours;
 912       while (n != NULL)
 913         {
 914           if (n->status == PEER_STATE_KEY_CONFIRMED)
 915             {
 916 #if DEBUG_CORE_CLIENT
 917               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 918                           "Sending `%s' message to client.\n", "NOTIFY_CONNECT");
 919 #endif
 920               cnm.distance = htonl (n->last_distance);
 921               cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
 922               cnm.peer = n->peer;
 923               send_to_client (c, &cnm.header, GNUNET_NO);
 924             }
 925           n = n->next;
 926         }
 927     }
 928   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 929 }
 930
 931
 932 /**
 933  * A client disconnected, clean up.
 934  *
 935  * @param cls closure
 936  * @param client identification of the client
 937  */
 938 static void
 939 handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
 940 {
 941   struct Client *pos;
 942   struct Client *prev;
 943
 944   if (client == NULL)
 945     return;
 946 #if DEBUG_CORE_CLIENT
 947   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 948               "Client %p has disconnected from core service.\n",
 949               client);
 950 #endif
 951   prev = NULL;
 952   pos = clients;
 953   while (pos != NULL)
 954     {
 955       if (client == pos->client_handle)
 956         {
 957           if (prev == NULL)
 958             clients = pos->next;
 959           else
 960             prev->next = pos->next;
 961           GNUNET_free (pos);
 962           return;
 963         }
 964       prev = pos;
 965       pos = pos->next;
 966     }
 967   /* client never sent INIT */
 968 }
 969
 970
 971 /**
 972  * Handle REQUEST_INFO request.
 973  */
 974 static void
 975 handle_client_request_info (void *cls,
 976                             struct GNUNET_SERVER_Client *client,
 977                             const struct GNUNET_MessageHeader *message)
 978 {
 979   const struct RequestInfoMessage *rcm;
 980   struct Neighbour *n;
 981   struct ConfigurationInfoMessage cim;
 982   int32_t want_reserv;
 983   int32_t got_reserv;
 984   unsigned long long old_preference;
 985   struct GNUNET_SERVER_TransmitContext *tc;
 986
 987 #if DEBUG_CORE_CLIENT
 988   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 989               "Core service receives `%s' request.\n", "REQUEST_INFO");
 990 #endif
 991   rcm = (const struct RequestInfoMessage *) message;
 992   n = find_neighbour (&rcm->peer);
 993   memset (&cim, 0, sizeof (cim));
 994   if (n != NULL)
 995     {
 996       want_reserv = ntohl (rcm->reserve_inbound);
 997       if (n->bw_out_internal_limit.value__ != rcm->limit_outbound.value__)
 998         {
 999           n->bw_out_internal_limit = rcm->limit_outbound;
1000           n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
1001                                                   n->bw_out_external_limit);
1002           GNUNET_BANDWIDTH_tracker_update_quota (&n->available_recv_window,
1003                                                  n->bw_out);
1004           GNUNET_TRANSPORT_set_quota (transport,
1005                                       &n->peer,
1006                                       n->bw_in,
1007                                       n->bw_out,
1008                                       GNUNET_TIME_UNIT_FOREVER_REL,
1009                                       NULL, NULL);
1010         }
1011       if (want_reserv < 0)
1012         {
1013           got_reserv = want_reserv;
1014         }
1015       else if (want_reserv > 0)
1016         {
1017           if (GNUNET_BANDWIDTH_tracker_get_delay (&n->available_recv_window,
1018                                                   want_reserv).value == 0)
1019             got_reserv = want_reserv;
1020           else
1021             got_reserv = 0; /* all or nothing */
1022         }
1023       else
1024         got_reserv = 0;
1025       GNUNET_BANDWIDTH_tracker_consume (&n->available_recv_window,
1026                                         got_reserv);
1027       old_preference = n->current_preference;
1028       n->current_preference += GNUNET_ntohll(rcm->preference_change);
1029       if (old_preference > n->current_preference)
1030         {
1031           /* overflow; cap at maximum value */
1032           n->current_preference = ULLONG_MAX;
1033         }
1034       update_preference_sum (n->current_preference - old_preference);
1035 #if DEBUG_CORE_QUOTA
1036       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1037                   "Received reservation request for %d bytes for peer `%4s', reserved %d bytes\n",
1038                   (int) want_reserv,
1039                   GNUNET_i2s (&rcm->peer),
1040                   (int) got_reserv);
1041 #endif
1042       cim.reserved_amount = htonl (got_reserv);
1043       cim.bw_in = n->bw_in;
1044       cim.bw_out = n->bw_out;
1045       cim.preference = n->current_preference;
1046     }
1047   cim.header.size = htons (sizeof (struct ConfigurationInfoMessage));
1048   cim.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO);
1049   cim.peer = rcm->peer;
1050
1051 #if DEBUG_CORE_CLIENT
1052   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1053               "Sending `%s' message to client.\n", "CONFIGURATION_INFO");
1054 #endif
1055   tc = GNUNET_SERVER_transmit_context_create (client);
1056   GNUNET_SERVER_transmit_context_append_message (tc, &cim.header);
1057   GNUNET_SERVER_transmit_context_run (tc,
1058                                       GNUNET_TIME_UNIT_FOREVER_REL);
1059 }
1060
1061
1062 /**
1063  * Free the given entry for the neighbour (it has
1064  * already been removed from the list at this point).
1065  *
1066  * @param n neighbour to free
1067  */
1068 static void
1069 free_neighbour (struct Neighbour *n)
1070 {
1071   struct MessageEntry *m;
1072
1073 #if DEBUG_CORE
1074   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1075               "Destroying neighbour entry for peer `%4s'\n",
1076               GNUNET_i2s (&n->peer));
1077 #endif
1078   if (n->pitr != NULL)
1079     {
1080       GNUNET_PEERINFO_iterate_cancel (n->pitr);
1081       n->pitr = NULL;
1082     }
1083   if (n->skm != NULL)
1084     {
1085       GNUNET_free (n->skm);
1086       n->skm = NULL;
1087     }
1088   while (NULL != (m = n->messages))
1089     {
1090       n->messages = m->next;
1091       GNUNET_free (m);
1092     }
1093   while (NULL != (m = n->encrypted_head))
1094     {
1095       GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
1096                                    n->encrypted_tail,
1097                                    m);
1098       GNUNET_free (m);
1099     }
1100   if (NULL != n->th)
1101     {
1102       GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
1103       n->th = NULL;
1104     }
1105   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
1106     GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
1107   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
1108     GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
1109   if (n->quota_update_task != GNUNET_SCHEDULER_NO_TASK)
1110     GNUNET_SCHEDULER_cancel (sched, n->quota_update_task);
1111   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
1112     GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
1113   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
1114       GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
1115   if (n->status == PEER_STATE_KEY_CONFIRMED)
1116     GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), -1, GNUNET_NO);
1117   GNUNET_free_non_null (n->public_key);
1118   GNUNET_free_non_null (n->pending_ping);
1119   GNUNET_free_non_null (n->pending_pong);
1120   GNUNET_free (n);
1121 }
1122
1123
1124 /**
1125  * Check if we have encrypted messages for the specified neighbour
1126  * pending, and if so, check with the transport about sending them
1127  * out.
1128  *
1129  * @param n neighbour to check.
1130  */
1131 static void process_encrypted_neighbour_queue (struct Neighbour *n);
1132
1133
1134 /**
1135  * Encrypt size bytes from in and write the result to out.  Use the
1136  * key for outbound traffic of the given neighbour.
1137  *
1138  * @param n neighbour we are sending to
1139  * @param iv initialization vector to use
1140  * @param in ciphertext
1141  * @param out plaintext
1142  * @param size size of in/out
1143  * @return GNUNET_OK on success
1144  */
1145 static int
1146 do_encrypt (struct Neighbour *n,
1147             const GNUNET_HashCode * iv,
1148             const void *in, void *out, size_t size)
1149 {
1150   if (size != (uint16_t) size)
1151     {
1152       GNUNET_break (0);
1153       return GNUNET_NO;
1154     }
1155   GNUNET_assert (size ==
1156                  GNUNET_CRYPTO_aes_encrypt (in,
1157                                             (uint16_t) size,
1158                                             &n->encrypt_key,
1159                                             (const struct
1160                                              GNUNET_CRYPTO_AesInitializationVector
1161                                              *) iv, out));
1162   GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes encrypted"), size, GNUNET_NO);
1163 #if DEBUG_CORE
1164   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1165               "Encrypted %u bytes for `%4s' using key %u\n",
1166               (unsigned int) size,
1167               GNUNET_i2s (&n->peer),
1168               (unsigned int) n->encrypt_key.crc32);
1169 #endif
1170   return GNUNET_OK;
1171 }
1172
1173
1174 /**
1175  * Consider freeing the given neighbour since we may not need
1176  * to keep it around anymore.
1177  *
1178  * @param n neighbour to consider discarding
1179  */
1180 static void
1181 consider_free_neighbour (struct Neighbour *n);
1182
1183
1184 /**
1185  * Task triggered when a neighbour entry is about to time out
1186  * (and we should prevent this by sending a PING).
1187  *
1188  * @param cls the 'struct Neighbour'
1189  * @param tc scheduler context (not used)
1190  */
1191 static void
1192 send_keep_alive (void *cls,
1193                  const struct GNUNET_SCHEDULER_TaskContext *tc)
1194 {
1195   struct Neighbour *n = cls;
1196   struct GNUNET_TIME_Relative retry;
1197   struct GNUNET_TIME_Relative left;
1198   struct MessageEntry *me;
1199   struct PingMessage pp;
1200   struct PingMessage *pm;
1201
1202   n->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
1203   /* send PING */
1204   me = GNUNET_malloc (sizeof (struct MessageEntry) +
1205                       sizeof (struct PingMessage));
1206   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PING_DELAY);
1207   me->priority = PING_PRIORITY;
1208   me->size = sizeof (struct PingMessage);
1209   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
1210                                      n->encrypted_tail,
1211                                      n->encrypted_tail,
1212                                      me);
1213   pm = (struct PingMessage *) &me[1];
1214   pm->header.size = htons (sizeof (struct PingMessage));
1215   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
1216   pp.challenge = htonl (n->ping_challenge);
1217   pp.target = n->peer;
1218 #if DEBUG_HANDSHAKE
1219   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1220               "Encrypting `%s' message with challenge %u for `%4s' using key %u.\n",
1221               "PING",
1222               (unsigned int) n->ping_challenge,
1223               GNUNET_i2s (&n->peer),
1224               (unsigned int) n->encrypt_key.crc32);
1225 #endif
1226   do_encrypt (n,
1227               &n->peer.hashPubKey,
1228               &pp.challenge,
1229               &pm->challenge,
1230               sizeof (struct PingMessage) -
1231               sizeof (struct GNUNET_MessageHeader));
1232   process_encrypted_neighbour_queue (n);
1233   /* reschedule PING job */
1234   left = GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (n->last_activity,
1235                                                                        GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
1236   retry = GNUNET_TIME_relative_max (GNUNET_TIME_relative_divide (left, 2),
1237                                     MIN_PING_FREQUENCY);
1238   n->keep_alive_task
1239     = GNUNET_SCHEDULER_add_delayed (sched,
1240                                     retry,
1241                                     &send_keep_alive,
1242                                     n);
1243
1244 }
1245
1246
1247 /**
1248  * Task triggered when a neighbour entry might have gotten stale.
1249  *
1250  * @param cls the 'struct Neighbour'
1251  * @param tc scheduler context (not used)
1252  */
1253 static void
1254 consider_free_task (void *cls,
1255                     const struct GNUNET_SCHEDULER_TaskContext *tc)
1256 {
1257   struct Neighbour *n = cls;
1258
1259   n->dead_clean_task = GNUNET_SCHEDULER_NO_TASK;
1260   consider_free_neighbour (n);
1261 }
1262
1263
1264 /**
1265  * Consider freeing the given neighbour since we may not need
1266  * to keep it around anymore.
1267  *
1268  * @param n neighbour to consider discarding
1269  */
1270 static void
1271 consider_free_neighbour (struct Neighbour *n)
1272 {
1273   struct Neighbour *pos;
1274   struct Neighbour *prev;
1275   struct GNUNET_TIME_Relative left;
1276
1277   if ( (n->th != NULL) ||
1278        (n->pitr != NULL) ||
1279        (n->status == PEER_STATE_KEY_CONFIRMED) ||
1280        (GNUNET_YES == n->is_connected) )
1281     return; /* no chance */
1282
1283   left = GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (n->last_activity,
1284                                                                        GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
1285   if (left.value > 0)
1286     {
1287       if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
1288         GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
1289       n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
1290                                                          left,
1291                                                          &consider_free_task,
1292                                                          n);
1293       return;
1294     }
1295   /* actually free the neighbour... */
1296   prev = NULL;
1297   pos = neighbours;
1298   while (pos != n)
1299     {
1300       prev = pos;
1301       pos = pos->next;
1302     }
1303   if (prev == NULL)
1304     neighbours = n->next;
1305   else
1306     prev->next = n->next;
1307   GNUNET_assert (neighbour_count > 0);
1308   neighbour_count--;
1309   GNUNET_STATISTICS_set (stats,
1310                          gettext_noop ("# neighbour entries allocated"),
1311                          neighbour_count,
1312                          GNUNET_NO);
1313   free_neighbour (n);
1314 }
1315
1316
1317 /**
1318  * Function called when the transport service is ready to
1319  * receive an encrypted message for the respective peer
1320  *
1321  * @param cls neighbour to use message from
1322  * @param size number of bytes we can transmit
1323  * @param buf where to copy the message
1324  * @return number of bytes transmitted
1325  */
1326 static size_t
1327 notify_encrypted_transmit_ready (void *cls, size_t size, void *buf)
1328 {
1329   struct Neighbour *n = cls;
1330   struct MessageEntry *m;
1331   size_t ret;
1332   char *cbuf;
1333
1334   n->th = NULL;
1335   m = n->encrypted_head;
1336   if (m == NULL)
1337     {
1338 #if DEBUG_CORE
1339       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1340                   "Encrypted message queue empty, no messages added to buffer for `%4s'\n",
1341                   GNUNET_i2s (&n->peer));
1342 #endif
1343       return 0;
1344     }
1345   GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
1346                                n->encrypted_tail,
1347                                m);
1348   ret = 0;
1349   cbuf = buf;
1350   if (buf != NULL)
1351     {
1352       GNUNET_assert (size >= m->size);
1353       memcpy (cbuf, &m[1], m->size);
1354       ret = m->size;
1355       GNUNET_BANDWIDTH_tracker_consume (&n->available_send_window,
1356                                         m->size);
1357 #if DEBUG_CORE
1358       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1359                   "Copied message of type %u and size %u into transport buffer for `%4s'\n",
1360                   (unsigned int) ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
1361                   (unsigned int) ret,
1362                   GNUNET_i2s (&n->peer));
1363 #endif
1364       process_encrypted_neighbour_queue (n);
1365     }
1366   else
1367     {
1368 #if DEBUG_CORE
1369       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1370                   "Transmission of message of type %u and size %u failed\n",
1371                   (unsigned int) ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
1372                   (unsigned int) m->size);
1373 #endif
1374     }
1375   GNUNET_free (m);
1376   consider_free_neighbour (n);
1377   return ret;
1378 }
1379
1380
1381 /**
1382  * Check if we have plaintext messages for the specified neighbour
1383  * pending, and if so, consider batching and encrypting them (and
1384  * then trigger processing of the encrypted queue if needed).
1385  *
1386  * @param n neighbour to check.
1387  */
1388 static void process_plaintext_neighbour_queue (struct Neighbour *n);
1389
1390
1391 /**
1392  * Check if we have encrypted messages for the specified neighbour
1393  * pending, and if so, check with the transport about sending them
1394  * out.
1395  *
1396  * @param n neighbour to check.
1397  */
1398 static void
1399 process_encrypted_neighbour_queue (struct Neighbour *n)
1400 {
1401   struct MessageEntry *m;
1402
1403   if (n->th != NULL)
1404     return;  /* request already pending */
1405   m = n->encrypted_head;
1406   if (m == NULL)
1407     {
1408       /* encrypted queue empty, try plaintext instead */
1409       process_plaintext_neighbour_queue (n);
1410       return;
1411     }
1412 #if DEBUG_CORE
1413   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1414               "Asking transport for transmission of %u bytes to `%4s' in next %llu ms\n",
1415               (unsigned int) m->size,
1416               GNUNET_i2s (&n->peer),
1417               (unsigned long long) GNUNET_TIME_absolute_get_remaining (m->deadline).
1418               value);
1419 #endif
1420   n->th =
1421     GNUNET_TRANSPORT_notify_transmit_ready (transport, &n->peer,
1422                                             m->size,
1423                                             m->priority,
1424                                             GNUNET_TIME_absolute_get_remaining
1425                                             (m->deadline),
1426                                             &notify_encrypted_transmit_ready,
1427                                             n);
1428   if (n->th == NULL)
1429     {
1430       /* message request too large or duplicate request */
1431       GNUNET_break (0);
1432       /* discard encrypted message */
1433       GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
1434                                    n->encrypted_tail,
1435                                    m);
1436       GNUNET_free (m);
1437       process_encrypted_neighbour_queue (n);
1438     }
1439 }
1440
1441
1442 /**
1443  * Decrypt size bytes from in and write the result to out.  Use the
1444  * key for inbound traffic of the given neighbour.  This function does
1445  * NOT do any integrity-checks on the result.
1446  *
1447  * @param n neighbour we are receiving from
1448  * @param iv initialization vector to use
1449  * @param in ciphertext
1450  * @param out plaintext
1451  * @param size size of in/out
1452  * @return GNUNET_OK on success
1453  */
1454 static int
1455 do_decrypt (struct Neighbour *n,
1456             const GNUNET_HashCode * iv,
1457             const void *in, void *out, size_t size)
1458 {
1459   if (size != (uint16_t) size)
1460     {
1461       GNUNET_break (0);
1462       return GNUNET_NO;
1463     }
1464   if ((n->status != PEER_STATE_KEY_RECEIVED) &&
1465       (n->status != PEER_STATE_KEY_CONFIRMED))
1466     {
1467       GNUNET_break_op (0);
1468       return GNUNET_SYSERR;
1469     }
1470   if (size !=
1471       GNUNET_CRYPTO_aes_decrypt (in,
1472                                  (uint16_t) size,
1473                                  &n->decrypt_key,
1474                                  (const struct
1475                                   GNUNET_CRYPTO_AesInitializationVector *) iv,
1476                                  out))
1477     {
1478       GNUNET_break (0);
1479       return GNUNET_SYSERR;
1480     }
1481   GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes decrypted"), size, GNUNET_NO);
1482 #if DEBUG_CORE
1483   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1484               "Decrypted %u bytes from `%4s' using key %u\n",
1485               (unsigned int) size,
1486               GNUNET_i2s (&n->peer),
1487               (unsigned int) n->decrypt_key.crc32);
1488 #endif
1489   return GNUNET_OK;
1490 }
1491
1492
1493 /**
1494  * Select messages for transmission.  This heuristic uses a combination
1495  * of earliest deadline first (EDF) scheduling (with bounded horizon)
1496  * and priority-based discard (in case no feasible schedule exist) and
1497  * speculative optimization (defer any kind of transmission until
1498  * we either create a batch of significant size, 25% of max, or until
1499  * we are close to a deadline).  Furthermore, when scheduling the
1500  * heuristic also packs as many messages into the batch as possible,
1501  * starting with those with the earliest deadline.  Yes, this is fun.
1502  *
1503  * @param n neighbour to select messages from
1504  * @param size number of bytes to select for transmission
1505  * @param retry_time set to the time when we should try again
1506  *        (only valid if this function returns zero)
1507  * @return number of bytes selected, or 0 if we decided to
1508  *         defer scheduling overall; in that case, retry_time is set.
1509  */
1510 static size_t
1511 select_messages (struct Neighbour *n,
1512                  size_t size, struct GNUNET_TIME_Relative *retry_time)
1513 {
1514   struct MessageEntry *pos;
1515   struct MessageEntry *min;
1516   struct MessageEntry *last;
1517   unsigned int min_prio;
1518   struct GNUNET_TIME_Absolute t;
1519   struct GNUNET_TIME_Absolute now;
1520   struct GNUNET_TIME_Relative delta;
1521   uint64_t avail;
1522   struct GNUNET_TIME_Relative slack;     /* how long could we wait before missing deadlines? */
1523   size_t off;
1524   uint64_t tsize;
1525   unsigned int queue_size;
1526   int discard_low_prio;
1527
1528   GNUNET_assert (NULL != n->messages);
1529   now = GNUNET_TIME_absolute_get ();
1530   /* last entry in linked list of messages processed */
1531   last = NULL;
1532   /* should we remove the entry with the lowest
1533      priority from consideration for scheduling at the
1534      end of the loop? */
1535   queue_size = 0;
1536   tsize = 0;
1537   pos = n->messages;
1538   while (pos != NULL)
1539     {
1540       queue_size++;
1541       tsize += pos->size;
1542       pos = pos->next;
1543     }
1544   discard_low_prio = GNUNET_YES;
1545   while (GNUNET_YES == discard_low_prio)
1546     {
1547       min = NULL;
1548       min_prio = UINT_MAX;
1549       discard_low_prio = GNUNET_NO;
1550       /* calculate number of bytes available for transmission at time "t" */
1551       avail = GNUNET_BANDWIDTH_tracker_get_available (&n->available_send_window);
1552       t = now;
1553       /* how many bytes have we (hypothetically) scheduled so far */
1554       off = 0;
1555       /* maximum time we can wait before transmitting anything
1556          and still make all of our deadlines */
1557       slack = GNUNET_TIME_UNIT_FOREVER_REL;
1558       pos = n->messages;
1559       /* note that we use "*2" here because we want to look
1560          a bit further into the future; much more makes no
1561          sense since new message might be scheduled in the
1562          meantime... */
1563       while ((pos != NULL) && (off < size * 2))
1564         {
1565           if (pos->do_transmit == GNUNET_YES)
1566             {
1567               /* already removed from consideration */
1568               pos = pos->next;
1569               continue;
1570             }
1571           if (discard_low_prio == GNUNET_NO)
1572             {
1573               delta = GNUNET_TIME_absolute_get_difference (t, pos->deadline);
1574               if (delta.value > 0)
1575                 {
1576                   // FIXME: HUH? Check!
1577                   t = pos->deadline;
1578                   avail += GNUNET_BANDWIDTH_value_get_available_until (n->bw_out,
1579                                                                        delta);
1580                 }
1581               if (avail < pos->size)
1582                 {
1583                   // FIXME: HUH? Check!
1584                   discard_low_prio = GNUNET_YES;        /* we could not schedule this one! */
1585                 }
1586               else
1587                 {
1588                   avail -= pos->size;
1589                   /* update slack, considering both its absolute deadline
1590                      and relative deadlines caused by other messages
1591                      with their respective load */
1592                   slack = GNUNET_TIME_relative_min (slack,
1593                                                     GNUNET_BANDWIDTH_value_get_delay_for (n->bw_out,
1594                                                                                           avail));
1595                   if (pos->deadline.value <= now.value)
1596                     {
1597                       /* now or never */
1598                       slack = GNUNET_TIME_UNIT_ZERO;
1599                     }
1600                   else if (GNUNET_YES == pos->got_slack)
1601                     {
1602                       /* should be soon now! */
1603                       slack = GNUNET_TIME_relative_min (slack,
1604                                                         GNUNET_TIME_absolute_get_remaining (pos->slack_deadline));
1605                     }
1606                   else
1607                     {
1608                       slack =
1609                         GNUNET_TIME_relative_min (slack,
1610                                                   GNUNET_TIME_absolute_get_difference (now, pos->deadline));
1611                       pos->got_slack = GNUNET_YES;
1612                       pos->slack_deadline = GNUNET_TIME_absolute_min (pos->deadline,
1613                                                                       GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY));
1614                     }
1615                 }
1616             }
1617           off += pos->size;
1618           t = GNUNET_TIME_absolute_max (pos->deadline, t); // HUH? Check!
1619           if (pos->priority <= min_prio)
1620             {
1621               /* update min for discard */
1622               min_prio = pos->priority;
1623               min = pos;
1624             }
1625           pos = pos->next;
1626         }
1627       if (discard_low_prio)
1628         {
1629           GNUNET_assert (min != NULL);
1630           /* remove lowest-priority entry from consideration */
1631           min->do_transmit = GNUNET_YES;        /* means: discard (for now) */
1632         }
1633       last = pos;
1634     }
1635   /* guard against sending "tiny" messages with large headers without
1636      urgent deadlines */
1637   if ( (slack.value > GNUNET_CONSTANTS_MAX_CORK_DELAY.value) &&
1638        (size > 4 * off) &&
1639        (queue_size <= MAX_PEER_QUEUE_SIZE - 2) )
1640     {
1641       /* less than 25% of message would be filled with deadlines still
1642          being met if we delay by one second or more; so just wait for
1643          more data; but do not wait longer than 1s (since we don't want
1644          to delay messages for a really long time either). */
1645       *retry_time = GNUNET_CONSTANTS_MAX_CORK_DELAY;
1646       /* reset do_transmit values for next time */
1647       while (pos != last)
1648         {
1649           pos->do_transmit = GNUNET_NO;
1650           pos = pos->next;
1651         }
1652 #if DEBUG_CORE
1653       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1654                   "Deferring transmission for %llums due to underfull message buffer size (%u/%u)\n",
1655                   (unsigned long long) retry_time->value,
1656                   (unsigned int) off,
1657                   (unsigned int) size);
1658 #endif
1659       return 0;
1660     }
1661   /* select marked messages (up to size) for transmission */
1662   off = 0;
1663   pos = n->messages;
1664   while (pos != last)
1665     {
1666       if ((pos->size <= size) && (pos->do_transmit == GNUNET_NO))
1667         {
1668           pos->do_transmit = GNUNET_YES;        /* mark for transmission */
1669           off += pos->size;
1670           size -= pos->size;
1671 #if DEBUG_CORE
1672           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1673                       "Selecting message of size %u for transmission\n",
1674                       (unsigned int) pos->size);
1675 #endif
1676         }
1677       else
1678         {
1679 #if DEBUG_CORE
1680           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1681                       "Not selecting message of size %u for transmission at this time (maximum is %u)\n",
1682                       (unsigned int) pos->size,
1683                       size);
1684 #endif
1685           pos->do_transmit = GNUNET_NO;   /* mark for not transmitting! */
1686         }
1687       pos = pos->next;
1688     }
1689 #if DEBUG_CORE
1690   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1691               "Selected %llu/%llu bytes of %u/%u plaintext messages for transmission to `%4s'.\n",
1692               (unsigned long long) off, (unsigned long long) tsize,
1693               queue_size, (unsigned int) MAX_PEER_QUEUE_SIZE,
1694               GNUNET_i2s (&n->peer));
1695 #endif
1696   return off;
1697 }
1698
1699
1700 /**
1701  * Batch multiple messages into a larger buffer.
1702  *
1703  * @param n neighbour to take messages from
1704  * @param buf target buffer
1705  * @param size size of buf
1706  * @param deadline set to transmission deadline for the result
1707  * @param retry_time set to the time when we should try again
1708  *        (only valid if this function returns zero)
1709  * @param priority set to the priority of the batch
1710  * @return number of bytes written to buf (can be zero)
1711  */
1712 static size_t
1713 batch_message (struct Neighbour *n,
1714                char *buf,
1715                size_t size,
1716                struct GNUNET_TIME_Absolute *deadline,
1717                struct GNUNET_TIME_Relative *retry_time,
1718                unsigned int *priority)
1719 {
1720   char ntmb[GNUNET_SERVER_MAX_MESSAGE_SIZE];
1721   struct NotifyTrafficMessage *ntm = (struct NotifyTrafficMessage*) ntmb;
1722   struct MessageEntry *pos;
1723   struct MessageEntry *prev;
1724   struct MessageEntry *next;
1725   size_t ret;
1726
1727   ret = 0;
1728   *priority = 0;
1729   *deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
1730   *retry_time = GNUNET_TIME_UNIT_FOREVER_REL;
1731   if (0 == select_messages (n, size, retry_time))
1732     {
1733 #if DEBUG_CORE
1734       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1735                   "No messages selected, will try again in %llu ms\n",
1736                   retry_time->value);
1737 #endif
1738       return 0;
1739     }
1740   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND);
1741   ntm->distance = htonl (n->last_distance);
1742   ntm->latency = GNUNET_TIME_relative_hton (n->last_latency);
1743   ntm->peer = n->peer;
1744   pos = n->messages;
1745   prev = NULL;
1746   while ((pos != NULL) && (size >= sizeof (struct GNUNET_MessageHeader)))
1747     {
1748       next = pos->next;
1749       if (GNUNET_YES == pos->do_transmit)
1750         {
1751           GNUNET_assert (pos->size <= size);
1752           /* do notifications */
1753           /* FIXME: track if we have *any* client that wants
1754              full notifications and only do this if that is
1755              actually true */
1756           if (pos->size < GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct NotifyTrafficMessage))
1757             {
1758               memcpy (&ntm[1], &pos[1], pos->size);
1759               ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) +
1760                                         sizeof (struct GNUNET_MessageHeader));
1761               send_to_all_clients (&ntm->header,
1762                                    GNUNET_YES,
1763                                    GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
1764             }
1765           else
1766             {
1767               /* message too large for 'full' notifications, we do at
1768                  least the 'hdr' type */
1769               memcpy (&ntm[1],
1770                       &pos[1],
1771                       sizeof (struct GNUNET_MessageHeader));
1772             }
1773           ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) +
1774                                     pos->size);
1775           send_to_all_clients (&ntm->header,
1776                                GNUNET_YES,
1777                                GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
1778 #if DEBUG_HANDSHAKE
1779           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1780                       "Encrypting %u bytes with message of type %u and size %u\n",
1781                       pos->size,
1782                       (unsigned int) ntohs(((const struct GNUNET_MessageHeader*)&pos[1])->type),
1783                       (unsigned int) ntohs(((const struct GNUNET_MessageHeader*)&pos[1])->size));
1784 #endif
1785           /* copy for encrypted transmission */
1786           memcpy (&buf[ret], &pos[1], pos->size);
1787           ret += pos->size;
1788           size -= pos->size;
1789           *priority += pos->priority;
1790 #if DEBUG_CORE
1791           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1792                       "Adding plaintext message of size %u with deadline %llu ms to batch\n",
1793                       (unsigned int) pos->size,
1794                       (unsigned long long) GNUNET_TIME_absolute_get_remaining (pos->deadline).value);
1795 #endif
1796           deadline->value = GNUNET_MIN (deadline->value, pos->deadline.value);
1797           GNUNET_free (pos);
1798           if (prev == NULL)
1799             n->messages = next;
1800           else
1801             prev->next = next;
1802         }
1803       else
1804         {
1805           prev = pos;
1806         }
1807       pos = next;
1808     }
1809 #if DEBUG_CORE
1810   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1811               "Deadline for message batch is %llu ms\n",
1812               GNUNET_TIME_absolute_get_remaining (*deadline).value);
1813 #endif
1814   return ret;
1815 }
1816
1817
1818 /**
1819  * Remove messages with deadlines that have long expired from
1820  * the queue.
1821  *
1822  * @param n neighbour to inspect
1823  */
1824 static void
1825 discard_expired_messages (struct Neighbour *n)
1826 {
1827   struct MessageEntry *prev;
1828   struct MessageEntry *next;
1829   struct MessageEntry *pos;
1830   struct GNUNET_TIME_Absolute now;
1831   struct GNUNET_TIME_Relative delta;
1832
1833   now = GNUNET_TIME_absolute_get ();
1834   prev = NULL;
1835   pos = n->messages;
1836   while (pos != NULL)
1837     {
1838       next = pos->next;
1839       delta = GNUNET_TIME_absolute_get_difference (pos->deadline, now);
1840       if (delta.value > PAST_EXPIRATION_DISCARD_TIME.value)
1841         {
1842 #if DEBUG_CORE
1843           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1844                       "Message is %llu ms past due, discarding.\n",
1845                       delta.value);
1846 #endif
1847           if (prev == NULL)
1848             n->messages = next;
1849           else
1850             prev->next = next;
1851           GNUNET_free (pos);
1852         }
1853       else
1854         prev = pos;
1855       pos = next;
1856     }
1857 }
1858
1859
1860 /**
1861  * Signature of the main function of a task.
1862  *
1863  * @param cls closure
1864  * @param tc context information (why was this task triggered now)
1865  */
1866 static void
1867 retry_plaintext_processing (void *cls,
1868                             const struct GNUNET_SCHEDULER_TaskContext *tc)
1869 {
1870   struct Neighbour *n = cls;
1871
1872   n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
1873   process_plaintext_neighbour_queue (n);
1874 }
1875
1876
1877 /**
1878  * Send our key (and encrypted PING) to the other peer.
1879  *
1880  * @param n the other peer
1881  */
1882 static void send_key (struct Neighbour *n);
1883
1884 /**
1885  * Task that will retry "send_key" if our previous attempt failed
1886  * to yield a PONG.
1887  */
1888 static void
1889 set_key_retry_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1890 {
1891   struct Neighbour *n = cls;
1892
1893 #if DEBUG_CORE
1894   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1895               "Retrying key transmission to `%4s'\n",
1896               GNUNET_i2s (&n->peer));
1897 #endif
1898   n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
1899   n->set_key_retry_frequency =
1900     GNUNET_TIME_relative_multiply (n->set_key_retry_frequency, 2);
1901   send_key (n);
1902 }
1903
1904
1905 /**
1906  * Check if we have plaintext messages for the specified neighbour
1907  * pending, and if so, consider batching and encrypting them (and
1908  * then trigger processing of the encrypted queue if needed).
1909  *
1910  * @param n neighbour to check.
1911  */
1912 static void
1913 process_plaintext_neighbour_queue (struct Neighbour *n)
1914 {
1915   char pbuf[GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE + sizeof (struct EncryptedMessage)];        /* plaintext */
1916   size_t used;
1917   size_t esize;
1918   struct EncryptedMessage *em;  /* encrypted message */
1919   struct EncryptedMessage *ph;  /* plaintext header */
1920   struct MessageEntry *me;
1921   unsigned int priority;
1922   struct GNUNET_TIME_Absolute deadline;
1923   struct GNUNET_TIME_Relative retry_time;
1924   GNUNET_HashCode iv;
1925
1926   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
1927     {
1928       GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
1929       n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
1930     }
1931   switch (n->status)
1932     {
1933     case PEER_STATE_DOWN:
1934       send_key (n);
1935 #if DEBUG_CORE
1936       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1937                   "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
1938                   GNUNET_i2s(&n->peer));
1939 #endif
1940       return;
1941     case PEER_STATE_KEY_SENT:
1942       if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
1943         n->retry_set_key_task
1944           = GNUNET_SCHEDULER_add_delayed (sched,
1945                                           n->set_key_retry_frequency,
1946                                           &set_key_retry_task, n);
1947 #if DEBUG_CORE
1948       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1949                   "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
1950                   GNUNET_i2s(&n->peer));
1951 #endif
1952       return;
1953     case PEER_STATE_KEY_RECEIVED:
1954       if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
1955         n->retry_set_key_task
1956           = GNUNET_SCHEDULER_add_delayed (sched,
1957                                           n->set_key_retry_frequency,
1958                                           &set_key_retry_task, n);
1959 #if DEBUG_CORE
1960       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1961                   "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
1962                   GNUNET_i2s(&n->peer));
1963 #endif
1964       return;
1965     case PEER_STATE_KEY_CONFIRMED:
1966       /* ready to continue */
1967       break;
1968     }
1969   discard_expired_messages (n);
1970   if (n->messages == NULL)
1971     {
1972 #if DEBUG_CORE
1973       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1974                   "Plaintext message queue for `%4s' is empty.\n",
1975                   GNUNET_i2s(&n->peer));
1976 #endif
1977       return;                   /* no pending messages */
1978     }
1979   if (n->encrypted_head != NULL)
1980     {
1981 #if DEBUG_CORE
1982       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1983                   "Encrypted message queue for `%4s' is still full, delaying plaintext processing.\n",
1984                   GNUNET_i2s(&n->peer));
1985 #endif
1986       return;                   /* wait for messages already encrypted to be
1987                                    processed first! */
1988     }
1989   ph = (struct EncryptedMessage *) pbuf;
1990   deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
1991   priority = 0;
1992   used = sizeof (struct EncryptedMessage);
1993   used += batch_message (n,
1994                          &pbuf[used],
1995                          GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE,
1996                          &deadline, &retry_time, &priority);
1997   if (used == sizeof (struct EncryptedMessage))
1998     {
1999 #if DEBUG_CORE
2000       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2001                   "No messages selected for transmission to `%4s' at this time, will try again later.\n",
2002                   GNUNET_i2s(&n->peer));
2003 #endif
2004       /* no messages selected for sending, try again later... */
2005       n->retry_plaintext_task =
2006         GNUNET_SCHEDULER_add_delayed (sched,
2007                                       retry_time,
2008                                       &retry_plaintext_processing, n);
2009       return;
2010     }
2011 #if DEBUG_CORE_QUOTA
2012   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2013               "Sending %u b/s as new limit to peer `%4s'\n",
2014               (unsigned int) ntohl (n->bw_in.value__),
2015               GNUNET_i2s (&n->peer));
2016 #endif
2017   ph->iv_seed = htonl (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX));
2018   ph->sequence_number = htonl (++n->last_sequence_number_sent);
2019   ph->inbound_bw_limit = n->bw_in;
2020   ph->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
2021
2022   /* setup encryption message header */
2023   me = GNUNET_malloc (sizeof (struct MessageEntry) + used);
2024   me->deadline = deadline;
2025   me->priority = priority;
2026   me->size = used;
2027   em = (struct EncryptedMessage *) &me[1];
2028   em->header.size = htons (used);
2029   em->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE);
2030   em->iv_seed = ph->iv_seed;
2031   esize = used - ENCRYPTED_HEADER_SIZE;
2032   GNUNET_CRYPTO_hash (&ph->sequence_number,
2033                       esize - sizeof (GNUNET_HashCode),
2034                       &ph->plaintext_hash);
2035   GNUNET_CRYPTO_hash (&ph->iv_seed, sizeof (uint32_t), &iv);
2036 #if DEBUG_HANDSHAKE
2037   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2038               "Hashed %u bytes of plaintext (`%s') using IV `%d'\n",
2039               (unsigned int) (esize - sizeof (GNUNET_HashCode)),
2040               GNUNET_h2s (&ph->plaintext_hash),
2041               (int) ph->iv_seed);
2042 #endif
2043   /* encrypt */
2044 #if DEBUG_HANDSHAKE
2045   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2046               "Encrypting %u bytes of plaintext messages for `%4s' for transmission in %llums.\n",
2047               (unsigned int) esize,
2048               GNUNET_i2s(&n->peer),
2049               (unsigned long long) GNUNET_TIME_absolute_get_remaining (deadline).value);
2050 #endif
2051   GNUNET_assert (GNUNET_OK ==
2052                  do_encrypt (n,
2053                              &iv,
2054                              &ph->plaintext_hash,
2055                              &em->plaintext_hash, esize));
2056   /* append to transmission list */
2057   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2058                                      n->encrypted_tail,
2059                                      n->encrypted_tail,
2060                                      me);
2061   process_encrypted_neighbour_queue (n);
2062 }
2063
2064
2065 /**
2066  * Function that recalculates the bandwidth quota for the
2067  * given neighbour and transmits it to the transport service.
2068  *
2069  * @param cls neighbour for the quota update
2070  * @param tc context
2071  */
2072 static void
2073 neighbour_quota_update (void *cls,
2074                         const struct GNUNET_SCHEDULER_TaskContext *tc);
2075
2076
2077 /**
2078  * Schedule the task that will recalculate the bandwidth
2079  * quota for this peer (and possibly force a disconnect of
2080  * idle peers by calculating a bandwidth of zero).
2081  */
2082 static void
2083 schedule_quota_update (struct Neighbour *n)
2084 {
2085   GNUNET_assert (n->quota_update_task ==
2086                  GNUNET_SCHEDULER_NO_TASK);
2087   n->quota_update_task
2088     = GNUNET_SCHEDULER_add_delayed (sched,
2089                                     QUOTA_UPDATE_FREQUENCY,
2090                                     &neighbour_quota_update,
2091                                     n);
2092 }
2093
2094
2095 /**
2096  * Initialize a new 'struct Neighbour'.
2097  *
2098  * @param pid ID of the new neighbour
2099  * @return handle for the new neighbour
2100  */
2101 static struct Neighbour *
2102 create_neighbour (const struct GNUNET_PeerIdentity *pid)
2103 {
2104   struct Neighbour *n;
2105   struct GNUNET_TIME_Absolute now;
2106
2107 #if DEBUG_CORE
2108   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2109               "Creating neighbour entry for peer `%4s'\n",
2110               GNUNET_i2s (pid));
2111 #endif
2112   n = GNUNET_malloc (sizeof (struct Neighbour));
2113   n->next = neighbours;
2114   neighbours = n;
2115   neighbour_count++;
2116   GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), neighbour_count, GNUNET_NO);
2117   n->peer = *pid;
2118   GNUNET_CRYPTO_aes_create_session_key (&n->encrypt_key);
2119   now = GNUNET_TIME_absolute_get ();
2120   n->encrypt_key_created = now;
2121   n->last_activity = now;
2122   n->set_key_retry_frequency = INITIAL_SET_KEY_RETRY_FREQUENCY;
2123   n->bw_in = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
2124   n->bw_out = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
2125   n->bw_out_internal_limit = GNUNET_BANDWIDTH_value_init (UINT32_MAX);
2126   n->bw_out_external_limit = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
2127   n->ping_challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
2128                                                 UINT32_MAX);
2129   neighbour_quota_update (n, NULL);
2130   consider_free_neighbour (n);
2131   return n;
2132 }
2133
2134
2135 /**
2136  * Handle CORE_SEND request.
2137  *
2138  * @param cls unused
2139  * @param client the client issuing the request
2140  * @param message the "struct SendMessage"
2141  */
2142 static void
2143 handle_client_send (void *cls,
2144                     struct GNUNET_SERVER_Client *client,
2145                     const struct GNUNET_MessageHeader *message)
2146 {
2147   const struct SendMessage *sm;
2148   struct Neighbour *n;
2149   struct MessageEntry *prev;
2150   struct MessageEntry *pos;
2151   struct MessageEntry *e;
2152   struct MessageEntry *min_prio_entry;
2153   struct MessageEntry *min_prio_prev;
2154   unsigned int min_prio;
2155   unsigned int queue_size;
2156   uint16_t msize;
2157
2158   msize = ntohs (message->size);
2159   if (msize <
2160       sizeof (struct SendMessage) + sizeof (struct GNUNET_MessageHeader))
2161     {
2162       GNUNET_break (0);
2163       if (client != NULL)
2164         GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2165       return;
2166     }
2167   sm = (const struct SendMessage *) message;
2168   msize -= sizeof (struct SendMessage);
2169   if (0 == memcmp (&sm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2170     {
2171       /* FIXME: should we not allow loopback-injection here? */
2172       GNUNET_break (0);
2173       if (client != NULL)
2174         GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2175       return;
2176     }
2177   n = find_neighbour (&sm->peer);
2178   if (n == NULL)
2179     n = create_neighbour (&sm->peer);
2180 #if DEBUG_CORE
2181   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2182               "Core received `%s' request, queueing %u bytes of plaintext data for transmission to `%4s'.\n",
2183               "SEND",
2184               (unsigned int) msize,
2185               GNUNET_i2s (&sm->peer));
2186 #endif
2187   /* bound queue size */
2188   discard_expired_messages (n);
2189   min_prio = UINT32_MAX;
2190   min_prio_entry = NULL;
2191   min_prio_prev = NULL;
2192   queue_size = 0;
2193   prev = NULL;
2194   pos = n->messages;
2195   while (pos != NULL)
2196     {
2197       if (pos->priority < min_prio)
2198         {
2199           min_prio_entry = pos;
2200           min_prio_prev = prev;
2201           min_prio = pos->priority;
2202         }
2203       queue_size++;
2204       prev = pos;
2205       pos = pos->next;
2206     }
2207   if (queue_size >= MAX_PEER_QUEUE_SIZE)
2208     {
2209       /* queue full */
2210       if (ntohl(sm->priority) <= min_prio)
2211         {
2212           /* discard new entry */
2213 #if DEBUG_CORE
2214           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2215                       "Queue full (%u/%u), discarding new request (%u bytes of type %u)\n",
2216                       queue_size,
2217                       (unsigned int) MAX_PEER_QUEUE_SIZE,
2218                       (unsigned int) msize,
2219                       (unsigned int) ntohs (message->type));
2220 #endif
2221           if (client != NULL)
2222             GNUNET_SERVER_receive_done (client, GNUNET_OK);
2223           return;
2224         }
2225       /* discard "min_prio_entry" */
2226 #if DEBUG_CORE
2227       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2228                   "Queue full, discarding existing older request\n");
2229 #endif
2230       if (min_prio_prev == NULL)
2231         n->messages = min_prio_entry->next;
2232       else
2233         min_prio_prev->next = min_prio_entry->next;
2234       GNUNET_free (min_prio_entry);
2235     }
2236
2237 #if DEBUG_CORE
2238   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2239               "Adding transmission request for `%4s' of size %u to queue\n",
2240               GNUNET_i2s (&sm->peer),
2241               (unsigned int) msize);
2242 #endif
2243   e = GNUNET_malloc (sizeof (struct MessageEntry) + msize);
2244   e->deadline = GNUNET_TIME_absolute_ntoh (sm->deadline);
2245   e->priority = ntohl (sm->priority);
2246   e->size = msize;
2247   memcpy (&e[1], &sm[1], msize);
2248
2249   /* insert, keep list sorted by deadline */
2250   prev = NULL;
2251   pos = n->messages;
2252   while ((pos != NULL) && (pos->deadline.value < e->deadline.value))
2253     {
2254       prev = pos;
2255       pos = pos->next;
2256     }
2257   if (prev == NULL)
2258     n->messages = e;
2259   else
2260     prev->next = e;
2261   e->next = pos;
2262
2263   /* consider scheduling now */
2264   process_plaintext_neighbour_queue (n);
2265   if (client != NULL)
2266     GNUNET_SERVER_receive_done (client, GNUNET_OK);
2267 }
2268
2269
2270 /**
2271  * Function called when the transport service is ready to
2272  * receive a message.  Only resets 'n->th' to NULL.
2273  *
2274  * @param cls neighbour to use message from
2275  * @param size number of bytes we can transmit
2276  * @param buf where to copy the message
2277  * @return number of bytes transmitted
2278  */
2279 static size_t
2280 notify_transport_connect_done (void *cls, size_t size, void *buf)
2281 {
2282   struct Neighbour *n = cls;
2283
2284   n->th = NULL;
2285   if (buf == NULL)
2286     {
2287       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2288                   _("Failed to connect to `%4s': transport failed to connect\n"),
2289                   GNUNET_i2s (&n->peer));
2290       return 0;
2291     }
2292   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2293               _("TRANSPORT connection to peer `%4s' is up, trying to establish CORE connection\n"),
2294               GNUNET_i2s (&n->peer));
2295   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2296     GNUNET_SCHEDULER_cancel (sched,
2297                              n->retry_set_key_task);
2298   n->retry_set_key_task = GNUNET_SCHEDULER_add_now (sched,
2299                                                     &set_key_retry_task,
2300                                                     n);
2301   return 0;
2302 }
2303
2304
2305 /**
2306  * Handle CORE_REQUEST_CONNECT request.
2307  *
2308  * @param cls unused
2309  * @param client the client issuing the request
2310  * @param message the "struct ConnectMessage"
2311  */
2312 static void
2313 handle_client_request_connect (void *cls,
2314                                struct GNUNET_SERVER_Client *client,
2315                                const struct GNUNET_MessageHeader *message)
2316 {
2317   const struct ConnectMessage *cm = (const struct ConnectMessage*) message;
2318   struct Neighbour *n;
2319   struct GNUNET_TIME_Relative timeout;
2320
2321   if (0 == memcmp (&cm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2322     {
2323       GNUNET_break (0);
2324       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2325       return;
2326     }
2327   GNUNET_SERVER_receive_done (client, GNUNET_OK);
2328   n = find_neighbour (&cm->peer);
2329   if (n == NULL)
2330     n = create_neighbour (&cm->peer);
2331   if ( (GNUNET_YES == n->is_connected) ||
2332        (n->th != NULL) )
2333     return; /* already connected, or at least trying */
2334   GNUNET_STATISTICS_update (stats, gettext_noop ("# connection requests received"), 1, GNUNET_NO);
2335 #if DEBUG_CORE
2336   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2337               "Core received `%s' request for `%4s', will try to establish connection\n",
2338               "REQUEST_CONNECT",
2339               GNUNET_i2s (&cm->peer));
2340 #endif
2341   timeout = GNUNET_TIME_relative_ntoh (cm->timeout);
2342   /* ask transport to connect to the peer */
2343   n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2344                                                   &cm->peer,
2345                                                   sizeof (struct GNUNET_MessageHeader), 0,
2346                                                   timeout,
2347                                                   &notify_transport_connect_done,
2348                                                   n);
2349   GNUNET_break (NULL != n->th);
2350 }
2351
2352
2353 /**
2354  * List of handlers for the messages understood by this
2355  * service.
2356  */
2357 static struct GNUNET_SERVER_MessageHandler handlers[] = {
2358   {&handle_client_init, NULL,
2359    GNUNET_MESSAGE_TYPE_CORE_INIT, 0},
2360   {&handle_client_request_info, NULL,
2361    GNUNET_MESSAGE_TYPE_CORE_REQUEST_INFO,
2362    sizeof (struct RequestInfoMessage)},
2363   {&handle_client_send, NULL,
2364    GNUNET_MESSAGE_TYPE_CORE_SEND, 0},
2365   {&handle_client_request_connect, NULL,
2366    GNUNET_MESSAGE_TYPE_CORE_REQUEST_CONNECT,
2367    sizeof (struct ConnectMessage)},
2368   {NULL, NULL, 0, 0}
2369 };
2370
2371
2372 /**
2373  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2374  * the neighbour's struct and retry send_key.  Or, if we did not get a
2375  * HELLO, just do nothing.
2376  *
2377  * @param cls the 'struct Neighbour' to retry sending the key for
2378  * @param peer the peer for which this is the HELLO
2379  * @param hello HELLO message of that peer
2380  * @param trust amount of trust we currently have in that peer
2381  */
2382 static void
2383 process_hello_retry_send_key (void *cls,
2384                               const struct GNUNET_PeerIdentity *peer,
2385                               const struct GNUNET_HELLO_Message *hello,
2386                               uint32_t trust)
2387 {
2388   struct Neighbour *n = cls;
2389
2390   if (peer == NULL)
2391     {
2392 #if DEBUG_CORE
2393       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2394                   "Entered `%s' and `%s' is NULL!\n",
2395                   "process_hello_retry_send_key",
2396                   "peer");
2397 #endif
2398       n->pitr = NULL;
2399       if (n->public_key != NULL)
2400         {
2401           if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2402             {
2403               GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2404               n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2405             }
2406           GNUNET_STATISTICS_update (stats,
2407                                     gettext_noop ("# SET_KEY messages deferred (need public key)"),
2408                                     -1,
2409                                     GNUNET_NO);
2410           send_key (n);
2411         }
2412       else
2413         {
2414           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2415                       _("Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n"),
2416                       GNUNET_i2s (&n->peer));
2417           GNUNET_STATISTICS_update (stats,
2418                                     gettext_noop ("# Delayed connecting due to lack of public key"),
2419                                     1,
2420                                     GNUNET_NO);
2421           if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
2422             n->retry_set_key_task
2423               = GNUNET_SCHEDULER_add_delayed (sched,
2424                                               n->set_key_retry_frequency,
2425                                               &set_key_retry_task, n);
2426         }
2427       return;
2428     }
2429
2430 #if DEBUG_CORE
2431   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2432               "Entered `%s' for peer `%4s'\n",
2433               "process_hello_retry_send_key",
2434               GNUNET_i2s (peer));
2435 #endif
2436   if (n->public_key != NULL)
2437     {
2438       /* already have public key, why are we here? */
2439       GNUNET_break (0);
2440       return;
2441     }
2442
2443 #if DEBUG_CORE
2444   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2445               "Received new `%s' message for `%4s', initiating key exchange.\n",
2446               "HELLO",
2447               GNUNET_i2s (peer));
2448 #endif
2449   n->public_key =
2450     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2451   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2452     {
2453       GNUNET_STATISTICS_update (stats,
2454                                 gettext_noop ("# Error extracting public key from HELLO"),
2455                                 1,
2456                                 GNUNET_NO);
2457       GNUNET_free (n->public_key);
2458       n->public_key = NULL;
2459 #if DEBUG_CORE
2460   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2461               "GNUNET_HELLO_get_key returned awfully\n");
2462 #endif
2463       return;
2464     }
2465 }
2466
2467
2468 /**
2469  * Send our key (and encrypted PING) to the other peer.
2470  *
2471  * @param n the other peer
2472  */
2473 static void
2474 send_key (struct Neighbour *n)
2475 {
2476   struct MessageEntry *pos;
2477   struct SetKeyMessage *sm;
2478   struct MessageEntry *me;
2479   struct PingMessage pp;
2480   struct PingMessage *pm;
2481
2482   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2483     {
2484       GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2485       n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2486     }
2487   if (n->pitr != NULL)
2488     {
2489 #if DEBUG_CORE
2490       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2491                   "Key exchange in progress with `%4s'.\n",
2492                   GNUNET_i2s (&n->peer));
2493 #endif
2494       return; /* already in progress */
2495     }
2496   if (GNUNET_YES != n->is_connected)
2497     {
2498 #if DEBUG_CORE
2499       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2500                   "Not yet connected to peer `%4s'!\n",
2501                   GNUNET_i2s (&n->peer));
2502 #endif
2503       if (NULL == n->th)
2504         {
2505           GNUNET_STATISTICS_update (stats,
2506                                     gettext_noop ("# Asking transport to connect (for SET_KEY)"),
2507                                     1,
2508                                     GNUNET_NO);
2509           n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2510                                                           &n->peer,
2511                                                           sizeof (struct SetKeyMessage) + sizeof (struct PingMessage),
2512                                                           0,
2513                                                           GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2514                                                           &notify_encrypted_transmit_ready,
2515                                                           n);
2516         }
2517       return;
2518     }
2519 #if DEBUG_CORE
2520   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2521               "Asked to perform key exchange with `%4s'.\n",
2522               GNUNET_i2s (&n->peer));
2523 #endif
2524   if (n->public_key == NULL)
2525     {
2526       /* lookup n's public key, then try again */
2527 #if DEBUG_CORE
2528       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2529                   "Lacking public key for `%4s', trying to obtain one (send_key).\n",
2530                   GNUNET_i2s (&n->peer));
2531 #endif
2532       GNUNET_assert (n->pitr == NULL);
2533       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
2534                                          &n->peer,
2535                                          0,
2536                                          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20),
2537                                          &process_hello_retry_send_key, n);
2538       return;
2539     }
2540   pos = n->encrypted_head;
2541   while (pos != NULL)
2542     {
2543       if (GNUNET_YES == pos->is_setkey)
2544         {
2545           if (pos->sender_status == n->status)
2546             {
2547 #if DEBUG_CORE
2548               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2549                           "`%s' message for `%4s' queued already\n",
2550                           "SET_KEY",
2551                           GNUNET_i2s (&n->peer));
2552 #endif
2553               goto trigger_processing;
2554             }
2555           GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
2556                                        n->encrypted_tail,
2557                                        pos);
2558           GNUNET_free (pos);
2559 #if DEBUG_CORE
2560           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2561                       "Removing queued `%s' message for `%4s', will create a new one\n",
2562                       "SET_KEY",
2563                       GNUNET_i2s (&n->peer));
2564 #endif
2565           break;
2566         }
2567       pos = pos->next;
2568     }
2569
2570   /* update status */
2571   switch (n->status)
2572     {
2573     case PEER_STATE_DOWN:
2574       n->status = PEER_STATE_KEY_SENT;
2575       break;
2576     case PEER_STATE_KEY_SENT:
2577       break;
2578     case PEER_STATE_KEY_RECEIVED:
2579       break;
2580     case PEER_STATE_KEY_CONFIRMED:
2581       break;
2582     default:
2583       GNUNET_break (0);
2584       break;
2585     }
2586
2587
2588   /* first, set key message */
2589   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2590                       sizeof (struct SetKeyMessage) +
2591                       sizeof (struct PingMessage));
2592   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_SET_KEY_DELAY);
2593   me->priority = SET_KEY_PRIORITY;
2594   me->size = sizeof (struct SetKeyMessage) + sizeof (struct PingMessage);
2595   me->is_setkey = GNUNET_YES;
2596   me->got_slack = GNUNET_YES; /* do not defer this one! */
2597   me->sender_status = n->status;
2598   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2599                                      n->encrypted_tail,
2600                                      n->encrypted_tail,
2601                                      me);
2602   sm = (struct SetKeyMessage *) &me[1];
2603   sm->header.size = htons (sizeof (struct SetKeyMessage));
2604   sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SET_KEY);
2605   sm->sender_status = htonl ((int32_t) ((n->status == PEER_STATE_DOWN) ?
2606                                         PEER_STATE_KEY_SENT : n->status));
2607   sm->purpose.size =
2608     htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
2609            sizeof (struct GNUNET_TIME_AbsoluteNBO) +
2610            sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
2611            sizeof (struct GNUNET_PeerIdentity));
2612   sm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SET_KEY);
2613   sm->creation_time = GNUNET_TIME_absolute_hton (n->encrypt_key_created);
2614   sm->target = n->peer;
2615   GNUNET_assert (GNUNET_OK ==
2616                  GNUNET_CRYPTO_rsa_encrypt (&n->encrypt_key,
2617                                             sizeof (struct
2618                                                     GNUNET_CRYPTO_AesSessionKey),
2619                                             n->public_key,
2620                                             &sm->encrypted_key));
2621   GNUNET_assert (GNUNET_OK ==
2622                  GNUNET_CRYPTO_rsa_sign (my_private_key, &sm->purpose,
2623                                          &sm->signature));
2624   pm = (struct PingMessage *) &sm[1];
2625   pm->header.size = htons (sizeof (struct PingMessage));
2626   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
2627   pp.challenge = htonl (n->ping_challenge);
2628   pp.target = n->peer;
2629 #if DEBUG_HANDSHAKE
2630   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2631               "Encrypting `%s' and `%s' messages with challenge %u for `%4s' using key %u.\n",
2632               "SET_KEY", "PING",
2633               (unsigned int) n->ping_challenge,
2634               GNUNET_i2s (&n->peer),
2635               (unsigned int) n->encrypt_key.crc32);
2636 #endif
2637   do_encrypt (n,
2638               &n->peer.hashPubKey,
2639               &pp.challenge,
2640               &pm->challenge,
2641               sizeof (struct PingMessage) -
2642               sizeof (struct GNUNET_MessageHeader));
2643   GNUNET_STATISTICS_update (stats,
2644                             gettext_noop ("# SET_KEY and PING messages created"),
2645                             1,
2646                             GNUNET_NO);
2647 #if DEBUG_CORE
2648   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2649               "Have %llu ms left for `%s' transmission.\n",
2650               (unsigned long long) GNUNET_TIME_absolute_get_remaining (me->deadline).value,
2651               "SET_KEY");
2652 #endif
2653  trigger_processing:
2654   /* trigger queue processing */
2655   process_encrypted_neighbour_queue (n);
2656   if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
2657        (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
2658     n->retry_set_key_task
2659       = GNUNET_SCHEDULER_add_delayed (sched,
2660                                       n->set_key_retry_frequency,
2661                                       &set_key_retry_task, n);
2662 }
2663
2664
2665 /**
2666  * We received a SET_KEY message.  Validate and update
2667  * our key material and status.
2668  *
2669  * @param n the neighbour from which we received message m
2670  * @param m the set key message we received
2671  */
2672 static void
2673 handle_set_key (struct Neighbour *n,
2674                 const struct SetKeyMessage *m);
2675
2676
2677 /**
2678  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2679  * the neighbour's struct and retry handling the set_key message.  Or,
2680  * if we did not get a HELLO, just free the set key message.
2681  *
2682  * @param cls pointer to the set key message
2683  * @param peer the peer for which this is the HELLO
2684  * @param hello HELLO message of that peer
2685  * @param trust amount of trust we currently have in that peer
2686  */
2687 static void
2688 process_hello_retry_handle_set_key (void *cls,
2689                                     const struct GNUNET_PeerIdentity *peer,
2690                                     const struct GNUNET_HELLO_Message *hello,
2691                                     uint32_t trust)
2692 {
2693   struct Neighbour *n = cls;
2694   struct SetKeyMessage *sm = n->skm;
2695
2696   if (peer == NULL)
2697     {
2698       n->skm = NULL;
2699       n->pitr = NULL;
2700       if (n->public_key != NULL)
2701         {
2702 #if DEBUG_CORE
2703           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2704                       "Received `%s' for `%4s', continuing processing of `%s' message.\n",
2705                       "HELLO",
2706                       GNUNET_i2s (&n->peer),
2707                       "SET_KEY");
2708 #endif
2709           handle_set_key (n, sm);
2710         }
2711       else
2712         {
2713           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2714                       _("Ignoring `%s' message due to lack of public key for peer `%4s' (failed to obtain one).\n"),
2715                       "SET_KEY",
2716                       GNUNET_i2s (&n->peer));
2717         }
2718       GNUNET_free (sm);
2719       return;
2720     }
2721   if (n->public_key != NULL)
2722     return;                     /* multiple HELLOs match!? */
2723   n->public_key =
2724     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2725   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2726     {
2727       GNUNET_break_op (0);
2728       GNUNET_free (n->public_key);
2729       n->public_key = NULL;
2730     }
2731 }
2732
2733
2734 /**
2735  * We received a PING message.  Validate and transmit
2736  * PONG.
2737  *
2738  * @param n sender of the PING
2739  * @param m the encrypted PING message itself
2740  */
2741 static void
2742 handle_ping (struct Neighbour *n, const struct PingMessage *m)
2743 {
2744   struct PingMessage t;
2745   struct PongMessage tx;
2746   struct PongMessage *tp;
2747   struct MessageEntry *me;
2748
2749 #if DEBUG_CORE
2750   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2751               "Core service receives `%s' request from `%4s'.\n",
2752               "PING", GNUNET_i2s (&n->peer));
2753 #endif
2754   if (GNUNET_OK !=
2755       do_decrypt (n,
2756                   &my_identity.hashPubKey,
2757                   &m->challenge,
2758                   &t.challenge,
2759                   sizeof (struct PingMessage) -
2760                   sizeof (struct GNUNET_MessageHeader)))
2761     return;
2762 #if DEBUG_HANDSHAKE
2763   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2764               "Decrypted `%s' to `%4s' with challenge %u decrypted using key %u\n",
2765               "PING",
2766               GNUNET_i2s (&t.target),
2767               (unsigned int) ntohl (t.challenge),
2768               (unsigned int) n->decrypt_key.crc32);
2769 #endif
2770   GNUNET_STATISTICS_update (stats,
2771                             gettext_noop ("# PING messages decrypted"),
2772                             1,
2773                             GNUNET_NO);
2774   if (0 != memcmp (&t.target,
2775                    &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2776     {
2777       GNUNET_break_op (0);
2778       return;
2779     }
2780   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2781                       sizeof (struct PongMessage));
2782   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2783                                      n->encrypted_tail,
2784                                      n->encrypted_tail,
2785                                      me);
2786   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PONG_DELAY);
2787   me->priority = PONG_PRIORITY;
2788   me->size = sizeof (struct PongMessage);
2789   tx.reserved = htonl (0);
2790   tx.inbound_bw_limit = n->bw_in;
2791   tx.challenge = t.challenge;
2792   tx.target = t.target;
2793   tp = (struct PongMessage *) &me[1];
2794   tp->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PONG);
2795   tp->header.size = htons (sizeof (struct PongMessage));
2796   do_encrypt (n,
2797               &my_identity.hashPubKey,
2798               &tx.challenge,
2799               &tp->challenge,
2800               sizeof (struct PongMessage) -
2801               sizeof (struct GNUNET_MessageHeader));
2802   GNUNET_STATISTICS_update (stats,
2803                             gettext_noop ("# PONG messages created"),
2804                             1,
2805                             GNUNET_NO);
2806 #if DEBUG_HANDSHAKE
2807   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2808               "Encrypting `%s' with challenge %u using key %u\n",
2809               "PONG",
2810               (unsigned int) ntohl (t.challenge),
2811               (unsigned int) n->encrypt_key.crc32);
2812 #endif
2813   /* trigger queue processing */
2814   process_encrypted_neighbour_queue (n);
2815 }
2816
2817
2818 /**
2819  * We received a PONG message.  Validate and update our status.
2820  *
2821  * @param n sender of the PONG
2822  * @param m the encrypted PONG message itself
2823  */
2824 static void
2825 handle_pong (struct Neighbour *n,
2826              const struct PongMessage *m)
2827 {
2828   struct PongMessage t;
2829   struct ConnectNotifyMessage cnm;
2830
2831 #if DEBUG_CORE
2832   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2833               "Core service receives `%s' response from `%4s'.\n",
2834               "PONG", GNUNET_i2s (&n->peer));
2835 #endif
2836   /* mark as garbage, just to be sure */
2837   memset (&t, 255, sizeof (t));
2838   if (GNUNET_OK !=
2839       do_decrypt (n,
2840                   &n->peer.hashPubKey,
2841                   &m->challenge,
2842                   &t.challenge,
2843                   sizeof (struct PongMessage) -
2844                   sizeof (struct GNUNET_MessageHeader)))
2845     {
2846       GNUNET_break_op (0);
2847       return;
2848     }
2849   GNUNET_STATISTICS_update (stats,
2850                             gettext_noop ("# PONG messages decrypted"),
2851                             1,
2852                             GNUNET_NO);
2853   if (0 != ntohl (t.reserved))
2854     {
2855       GNUNET_break_op (0);
2856       return;
2857     }
2858 #if DEBUG_HANDSHAKE
2859   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2860               "Decrypted `%s' from `%4s' with challenge %u using key %u\n",
2861               "PONG",
2862               GNUNET_i2s (&t.target),
2863               (unsigned int) ntohl (t.challenge),
2864               (unsigned int) n->decrypt_key.crc32);
2865 #endif
2866   if ((0 != memcmp (&t.target,
2867                     &n->peer,
2868                     sizeof (struct GNUNET_PeerIdentity))) ||
2869       (n->ping_challenge != ntohl (t.challenge)))
2870     {
2871       /* PONG malformed */
2872 #if DEBUG_CORE
2873       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2874                   "Received malformed `%s' wanted sender `%4s' with challenge %u\n",
2875                   "PONG",
2876                   GNUNET_i2s (&n->peer),
2877                   (unsigned int) n->ping_challenge);
2878       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2879                   "Received malformed `%s' received from `%4s' with challenge %u\n",
2880                   "PONG", GNUNET_i2s (&t.target),
2881                   (unsigned int) ntohl (t.challenge));
2882 #endif
2883       GNUNET_break_op (0);
2884       return;
2885     }
2886   switch (n->status)
2887     {
2888     case PEER_STATE_DOWN:
2889       GNUNET_break (0);         /* should be impossible */
2890       return;
2891     case PEER_STATE_KEY_SENT:
2892       GNUNET_break (0);         /* should be impossible, how did we decrypt? */
2893       return;
2894     case PEER_STATE_KEY_RECEIVED:
2895       GNUNET_STATISTICS_update (stats,
2896                                 gettext_noop ("# Session keys confirmed via PONG"),
2897                                 1,
2898                                 GNUNET_NO);
2899       n->status = PEER_STATE_KEY_CONFIRMED;
2900       if (n->bw_out_external_limit.value__ != t.inbound_bw_limit.value__)
2901         {
2902           n->bw_out_external_limit = t.inbound_bw_limit;
2903           n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
2904                                                   n->bw_out_internal_limit);
2905           GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
2906                                                  n->bw_out);
2907           GNUNET_TRANSPORT_set_quota (transport,
2908                                       &n->peer,
2909                                       n->bw_in,
2910                                       n->bw_out,
2911                                       GNUNET_TIME_UNIT_FOREVER_REL,
2912                                       NULL, NULL);
2913         }
2914 #if DEBUG_CORE
2915       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2916                   "Confirmed key via `%s' message for peer `%4s'\n",
2917                   "PONG", GNUNET_i2s (&n->peer));
2918 #endif
2919       if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2920         {
2921           GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2922           n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2923         }
2924       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
2925       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
2926       cnm.distance = htonl (n->last_distance);
2927       cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
2928       cnm.peer = n->peer;
2929       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_CONNECT);
2930       process_encrypted_neighbour_queue (n);
2931       /* fall-through! */
2932     case PEER_STATE_KEY_CONFIRMED:
2933       n->last_activity = GNUNET_TIME_absolute_get ();
2934       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
2935         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
2936       n->keep_alive_task
2937         = GNUNET_SCHEDULER_add_delayed (sched,
2938                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
2939                                         &send_keep_alive,
2940                                         n);
2941       break;
2942     default:
2943       GNUNET_break (0);
2944       break;
2945     }
2946 }
2947
2948
2949 /**
2950  * We received a SET_KEY message.  Validate and update
2951  * our key material and status.
2952  *
2953  * @param n the neighbour from which we received message m
2954  * @param m the set key message we received
2955  */
2956 static void
2957 handle_set_key (struct Neighbour *n, const struct SetKeyMessage *m)
2958 {
2959   struct SetKeyMessage *m_cpy;
2960   struct GNUNET_TIME_Absolute t;
2961   struct GNUNET_CRYPTO_AesSessionKey k;
2962   struct PingMessage *ping;
2963   struct PongMessage *pong;
2964   enum PeerStateMachine sender_status;
2965
2966 #if DEBUG_CORE
2967   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2968               "Core service receives `%s' request from `%4s'.\n",
2969               "SET_KEY", GNUNET_i2s (&n->peer));
2970 #endif
2971   if (n->public_key == NULL)
2972     {
2973       if (n->pitr != NULL)
2974         {
2975 #if DEBUG_CORE
2976           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2977                       "Ignoring `%s' message due to lack of public key for peer (still trying to obtain one).\n",
2978                       "SET_KEY");
2979 #endif
2980           return;
2981         }
2982 #if DEBUG_CORE
2983       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2984                   "Lacking public key for peer, trying to obtain one (handle_set_key).\n");
2985 #endif
2986       m_cpy = GNUNET_malloc (sizeof (struct SetKeyMessage));
2987       memcpy (m_cpy, m, sizeof (struct SetKeyMessage));
2988       /* lookup n's public key, then try again */
2989       GNUNET_assert (n->skm == NULL);
2990       n->skm = m_cpy;
2991       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
2992                                          &n->peer,
2993                                          0,
2994                                          GNUNET_TIME_UNIT_MINUTES,
2995                                          &process_hello_retry_handle_set_key, n);
2996       GNUNET_STATISTICS_update (stats,
2997                                 gettext_noop ("# SET_KEY messages deferred (need public key)"),
2998                                 1,
2999                                 GNUNET_NO);
3000       return;
3001     }
3002   if (0 != memcmp (&m->target,
3003                    &my_identity,
3004                    sizeof (struct GNUNET_PeerIdentity)))
3005     {
3006       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3007                   _("Received `%s' message that was for `%s', not for me.  Ignoring.\n"),
3008                   "SET_KEY",
3009                   GNUNET_i2s (&m->target));
3010       return;
3011     }
3012   if ((ntohl (m->purpose.size) !=
3013        sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
3014        sizeof (struct GNUNET_TIME_AbsoluteNBO) +
3015        sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
3016        sizeof (struct GNUNET_PeerIdentity)) ||
3017       (GNUNET_OK !=
3018        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_SET_KEY,
3019                                  &m->purpose, &m->signature, n->public_key)))
3020     {
3021       /* invalid signature */
3022       GNUNET_break_op (0);
3023       return;
3024     }
3025   t = GNUNET_TIME_absolute_ntoh (m->creation_time);
3026   if (((n->status == PEER_STATE_KEY_RECEIVED) ||
3027        (n->status == PEER_STATE_KEY_CONFIRMED)) &&
3028       (t.value < n->decrypt_key_created.value))
3029     {
3030       /* this could rarely happen due to massive re-ordering of
3031          messages on the network level, but is most likely either
3032          a bug or some adversary messing with us.  Report. */
3033       GNUNET_break_op (0);
3034       return;
3035     }
3036 #if DEBUG_CORE
3037   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3038               "Decrypting key material.\n");
3039 #endif
3040   if ((GNUNET_CRYPTO_rsa_decrypt (my_private_key,
3041                                   &m->encrypted_key,
3042                                   &k,
3043                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey))
3044        != sizeof (struct GNUNET_CRYPTO_AesSessionKey)) ||
3045       (GNUNET_OK != GNUNET_CRYPTO_aes_check_session_key (&k)))
3046     {
3047       /* failed to decrypt !? */
3048       GNUNET_break_op (0);
3049       return;
3050     }
3051   GNUNET_STATISTICS_update (stats,
3052                             gettext_noop ("# SET_KEY messages decrypted"),
3053                             1,
3054                             GNUNET_NO);
3055   n->decrypt_key = k;
3056   if (n->decrypt_key_created.value != t.value)
3057     {
3058       /* fresh key, reset sequence numbers */
3059       n->last_sequence_number_received = 0;
3060       n->last_packets_bitmap = 0;
3061       n->decrypt_key_created = t;
3062     }
3063   sender_status = (enum PeerStateMachine) ntohl (m->sender_status);
3064   switch (n->status)
3065     {
3066     case PEER_STATE_DOWN:
3067       n->status = PEER_STATE_KEY_RECEIVED;
3068 #if DEBUG_CORE
3069       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3070                   "Responding to `%s' with my own key.\n", "SET_KEY");
3071 #endif
3072       send_key (n);
3073       break;
3074     case PEER_STATE_KEY_SENT:
3075     case PEER_STATE_KEY_RECEIVED:
3076       n->status = PEER_STATE_KEY_RECEIVED;
3077       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3078           (sender_status != PEER_STATE_KEY_CONFIRMED))
3079         {
3080 #if DEBUG_CORE
3081           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3082                       "Responding to `%s' with my own key (other peer has status %u).\n",
3083                       "SET_KEY",
3084                       (unsigned int) sender_status);
3085 #endif
3086           send_key (n);
3087         }
3088       break;
3089     case PEER_STATE_KEY_CONFIRMED:
3090       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3091           (sender_status != PEER_STATE_KEY_CONFIRMED))
3092         {
3093 #if DEBUG_CORE
3094           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3095                       "Responding to `%s' with my own key (other peer has status %u), I was already fully up.\n",
3096                       "SET_KEY",
3097                       (unsigned int) sender_status);
3098 #endif
3099           send_key (n);
3100         }
3101       break;
3102     default:
3103       GNUNET_break (0);
3104       break;
3105     }
3106   if (n->pending_ping != NULL)
3107     {
3108       ping = n->pending_ping;
3109       n->pending_ping = NULL;
3110       handle_ping (n, ping);
3111       GNUNET_free (ping);
3112     }
3113   if (n->pending_pong != NULL)
3114     {
3115       pong = n->pending_pong;
3116       n->pending_pong = NULL;
3117       handle_pong (n, pong);
3118       GNUNET_free (pong);
3119     }
3120 }
3121
3122
3123 /**
3124  * Send a P2P message to a client.
3125  *
3126  * @param sender who sent us the message?
3127  * @param client who should we give the message to?
3128  * @param m contains the message to transmit
3129  * @param msize number of bytes in buf to transmit
3130  */
3131 static void
3132 send_p2p_message_to_client (struct Neighbour *sender,
3133                             struct Client *client,
3134                             const void *m, size_t msize)
3135 {
3136   char buf[msize + sizeof (struct NotifyTrafficMessage)];
3137   struct NotifyTrafficMessage *ntm;
3138
3139 #if DEBUG_CORE
3140   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3141               "Core service passes message from `%4s' of type %u to client.\n",
3142               GNUNET_i2s(&sender->peer),
3143               (unsigned int) ntohs (((const struct GNUNET_MessageHeader *) m)->type));
3144 #endif
3145   ntm = (struct NotifyTrafficMessage *) buf;
3146   ntm->header.size = htons (msize + sizeof (struct NotifyTrafficMessage));
3147   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND);
3148   ntm->distance = htonl (sender->last_distance);
3149   ntm->latency = GNUNET_TIME_relative_hton (sender->last_latency);
3150   ntm->peer = sender->peer;
3151   memcpy (&ntm[1], m, msize);
3152   send_to_client (client, &ntm->header, GNUNET_YES);
3153 }
3154
3155
3156 /**
3157  * Deliver P2P message to interested clients.
3158  *
3159  * @param sender who sent us the message?
3160  * @param m the message
3161  * @param msize size of the message (including header)
3162  */
3163 static void
3164 deliver_message (struct Neighbour *sender,
3165                  const struct GNUNET_MessageHeader *m, size_t msize)
3166 {
3167   char buf[256];
3168   struct Client *cpos;
3169   uint16_t type;
3170   unsigned int tpos;
3171   int deliver_full;
3172   int dropped;
3173
3174   type = ntohs (m->type);
3175 #if DEBUG_CORE
3176   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3177               "Received encapsulated message of type %u and size %u from `%4s'\n",
3178               (unsigned int) type,
3179               ntohs (m->size),
3180               GNUNET_i2s (&sender->peer));
3181 #endif
3182   GNUNET_snprintf (buf,
3183                    sizeof(buf),
3184                    gettext_noop ("# bytes of messages of type %u received"),
3185                    (unsigned int) type);
3186   GNUNET_STATISTICS_set (stats,
3187                          buf,
3188                          msize,
3189                          GNUNET_NO);
3190   dropped = GNUNET_YES;
3191   cpos = clients;
3192   while (cpos != NULL)
3193     {
3194       deliver_full = GNUNET_NO;
3195       if (0 != (cpos->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
3196         deliver_full = GNUNET_YES;
3197       else
3198         {
3199           for (tpos = 0; tpos < cpos->tcnt; tpos++)
3200             {
3201               if (type != cpos->types[tpos])
3202                 continue;
3203               deliver_full = GNUNET_YES;
3204               break;
3205             }
3206         }
3207       if (GNUNET_YES == deliver_full)
3208         {
3209           send_p2p_message_to_client (sender, cpos, m, msize);
3210           dropped = GNUNET_NO;
3211         }
3212       else if (cpos->options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)
3213         {
3214           send_p2p_message_to_client (sender, cpos, m,
3215                                       sizeof (struct GNUNET_MessageHeader));
3216         }
3217       cpos = cpos->next;
3218     }
3219   if (dropped == GNUNET_YES)
3220     {
3221 #if DEBUG_CORE
3222       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3223                   "Message of type %u from `%4s' not delivered to any client.\n",
3224                   (unsigned int) type,
3225                   GNUNET_i2s (&sender->peer));
3226 #endif
3227       /* FIXME: stats... */
3228     }
3229 }
3230
3231
3232 /**
3233  * Align P2P message and then deliver to interested clients.
3234  *
3235  * @param sender who sent us the message?
3236  * @param buffer unaligned (!) buffer containing message
3237  * @param msize size of the message (including header)
3238  */
3239 static void
3240 align_and_deliver (struct Neighbour *sender, const char *buffer, size_t msize)
3241 {
3242   char abuf[msize];
3243
3244   /* TODO: call to statistics? */
3245   memcpy (abuf, buffer, msize);
3246   deliver_message (sender, (const struct GNUNET_MessageHeader *) abuf, msize);
3247 }
3248
3249
3250 /**
3251  * Deliver P2P messages to interested clients.
3252  *
3253  * @param sender who sent us the message?
3254  * @param buffer buffer containing messages, can be modified
3255  * @param buffer_size size of the buffer (overall)
3256  * @param offset offset where messages in the buffer start
3257  */
3258 static void
3259 deliver_messages (struct Neighbour *sender,
3260                   const char *buffer, size_t buffer_size, size_t offset)
3261 {
3262   struct GNUNET_MessageHeader *mhp;
3263   struct GNUNET_MessageHeader mh;
3264   uint16_t msize;
3265   int need_align;
3266
3267   while (offset + sizeof (struct GNUNET_MessageHeader) <= buffer_size)
3268     {
3269       if (0 != offset % sizeof (uint16_t))
3270         {
3271           /* outch, need to copy to access header */
3272           memcpy (&mh, &buffer[offset], sizeof (struct GNUNET_MessageHeader));
3273           mhp = &mh;
3274         }
3275       else
3276         {
3277           /* can access header directly */
3278           mhp = (struct GNUNET_MessageHeader *) &buffer[offset];
3279         }
3280       msize = ntohs (mhp->size);
3281       if (msize + offset > buffer_size)
3282         {
3283           /* malformed message, header says it is larger than what
3284              would fit into the overall buffer */
3285           GNUNET_break_op (0);
3286           break;
3287         }
3288 #if HAVE_UNALIGNED_64_ACCESS
3289       need_align = (0 != offset % 4) ? GNUNET_YES : GNUNET_NO;
3290 #else
3291       need_align = (0 != offset % 8) ? GNUNET_YES : GNUNET_NO;
3292 #endif
3293 #if DEBUG_CORE
3294       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3295                   "Delivering %u bytes of message at offset %u/%u to clients.\n",
3296                   (unsigned int) msize,
3297                   (unsigned int) offset,
3298                   (unsigned int) buffer_size);
3299 #endif
3300
3301       if (GNUNET_YES == need_align)
3302         align_and_deliver (sender, &buffer[offset], msize);
3303       else
3304         deliver_message (sender,
3305                          (const struct GNUNET_MessageHeader *)
3306                          &buffer[offset], msize);
3307       offset += msize;
3308     }
3309 }
3310
3311
3312 /**
3313  * We received an encrypted message.  Decrypt, validate and
3314  * pass on to the appropriate clients.
3315  */
3316 static void
3317 handle_encrypted_message (struct Neighbour *n,
3318                           const struct EncryptedMessage *m)
3319 {
3320   size_t size = ntohs (m->header.size);
3321   char buf[size];
3322   struct EncryptedMessage *pt;  /* plaintext */
3323   GNUNET_HashCode ph;
3324   uint32_t snum;
3325   struct GNUNET_TIME_Absolute t;
3326   GNUNET_HashCode iv;
3327
3328 #if DEBUG_CORE
3329   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3330               "Core service receives `%s' request from `%4s'.\n",
3331               "ENCRYPTED_MESSAGE", GNUNET_i2s (&n->peer));
3332 #endif
3333   GNUNET_CRYPTO_hash (&m->iv_seed, sizeof (uint32_t), &iv);
3334   /* decrypt */
3335   if (GNUNET_OK !=
3336       do_decrypt (n,
3337                   &iv,
3338                   &m->plaintext_hash,
3339                   &buf[ENCRYPTED_HEADER_SIZE],
3340                   size - ENCRYPTED_HEADER_SIZE))
3341     return;
3342   pt = (struct EncryptedMessage *) buf;
3343   /* validate hash */
3344   GNUNET_CRYPTO_hash (&pt->sequence_number,
3345                       size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode), &ph);
3346 #if DEBUG_HANDSHAKE
3347   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3348               "V-Hashed %u bytes of plaintext (`%s') using IV `%d'\n",
3349               (unsigned int) (size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode)),
3350               GNUNET_h2s (&ph),
3351               (int) m->iv_seed);
3352 #endif
3353   if (0 != memcmp (&ph,
3354                    &pt->plaintext_hash,
3355                    sizeof (GNUNET_HashCode)))
3356     {
3357       /* checksum failed */
3358       GNUNET_break_op (0);
3359       return;
3360     }
3361
3362   /* validate sequence number */
3363   snum = ntohl (pt->sequence_number);
3364   if (n->last_sequence_number_received == snum)
3365     {
3366       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3367                   "Received duplicate message, ignoring.\n");
3368       /* duplicate, ignore */
3369       GNUNET_STATISTICS_set (stats,
3370                              gettext_noop ("# bytes dropped (duplicates)"),
3371                              size,
3372                              GNUNET_NO);
3373       return;
3374     }
3375   if ((n->last_sequence_number_received > snum) &&
3376       (n->last_sequence_number_received - snum > 32))
3377     {
3378       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3379                   "Received ancient out of sequence message, ignoring.\n");
3380       /* ancient out of sequence, ignore */
3381       GNUNET_STATISTICS_set (stats,
3382                              gettext_noop ("# bytes dropped (out of sequence)"),
3383                              size,
3384                              GNUNET_NO);
3385       return;
3386     }
3387   if (n->last_sequence_number_received > snum)
3388     {
3389       unsigned int rotbit =
3390         1 << (n->last_sequence_number_received - snum - 1);
3391       if ((n->last_packets_bitmap & rotbit) != 0)
3392         {
3393           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3394                       "Received duplicate message, ignoring.\n");
3395           GNUNET_STATISTICS_set (stats,
3396                                  gettext_noop ("# bytes dropped (duplicates)"),
3397                                  size,
3398                                  GNUNET_NO);
3399           /* duplicate, ignore */
3400           return;
3401         }
3402       n->last_packets_bitmap |= rotbit;
3403     }
3404   if (n->last_sequence_number_received < snum)
3405     {
3406       n->last_packets_bitmap <<= (snum - n->last_sequence_number_received);
3407       n->last_sequence_number_received = snum;
3408     }
3409
3410   /* check timestamp */
3411   t = GNUNET_TIME_absolute_ntoh (pt->timestamp);
3412   if (GNUNET_TIME_absolute_get_duration (t).value > MAX_MESSAGE_AGE.value)
3413     {
3414       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3415                   _
3416                   ("Message received far too old (%llu ms). Content ignored.\n"),
3417                   GNUNET_TIME_absolute_get_duration (t).value);
3418       GNUNET_STATISTICS_set (stats,
3419                              gettext_noop ("# bytes dropped (ancient message)"),
3420                              size,
3421                              GNUNET_NO);
3422       return;
3423     }
3424
3425   /* process decrypted message(s) */
3426   if (n->bw_out_external_limit.value__ != pt->inbound_bw_limit.value__)
3427     {
3428 #if DEBUG_CORE_SET_QUOTA
3429       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3430                   "Received %u b/s as new inbound limit for peer `%4s'\n",
3431                   (unsigned int) ntohl (pt->inbound_bw_limit.value__),
3432                   GNUNET_i2s (&n->peer));
3433 #endif
3434       n->bw_out_external_limit = pt->inbound_bw_limit;
3435       n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
3436                                               n->bw_out_internal_limit);
3437       GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
3438                                              n->bw_out);
3439       GNUNET_TRANSPORT_set_quota (transport,
3440                                   &n->peer,
3441                                   n->bw_in,
3442                                   n->bw_out,
3443                                   GNUNET_TIME_UNIT_FOREVER_REL,
3444                                   NULL, NULL);
3445     }
3446   n->last_activity = GNUNET_TIME_absolute_get ();
3447   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3448     GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3449   n->keep_alive_task
3450     = GNUNET_SCHEDULER_add_delayed (sched,
3451                                     GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3452                                     &send_keep_alive,
3453                                     n);
3454   GNUNET_STATISTICS_set (stats,
3455                          gettext_noop ("# bytes of payload decrypted"),
3456                          size - sizeof (struct EncryptedMessage),
3457                          GNUNET_NO);
3458   deliver_messages (n, buf, size, sizeof (struct EncryptedMessage));
3459 }
3460
3461
3462 /**
3463  * Function called by the transport for each received message.
3464  *
3465  * @param cls closure
3466  * @param peer (claimed) identity of the other peer
3467  * @param message the message
3468  * @param latency estimated latency for communicating with the
3469  *             given peer (round-trip)
3470  * @param distance in overlay hops, as given by transport plugin
3471  */
3472 static void
3473 handle_transport_receive (void *cls,
3474                           const struct GNUNET_PeerIdentity *peer,
3475                           const struct GNUNET_MessageHeader *message,
3476                           struct GNUNET_TIME_Relative latency,
3477                           unsigned int distance)
3478 {
3479   struct Neighbour *n;
3480   struct GNUNET_TIME_Absolute now;
3481   int up;
3482   uint16_t type;
3483   uint16_t size;
3484
3485 #if DEBUG_CORE
3486   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3487               "Received message of type %u from `%4s', demultiplexing.\n",
3488               (unsigned int) ntohs (message->type),
3489               GNUNET_i2s (peer));
3490 #endif
3491   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3492     {
3493       GNUNET_break (0);
3494       return;
3495     }
3496   n = find_neighbour (peer);
3497   if (n == NULL)
3498     n = create_neighbour (peer);
3499   n->last_latency = latency;
3500   n->last_distance = distance;
3501   up = (n->status == PEER_STATE_KEY_CONFIRMED);
3502   type = ntohs (message->type);
3503   size = ntohs (message->size);
3504   switch (type)
3505     {
3506     case GNUNET_MESSAGE_TYPE_CORE_SET_KEY:
3507       if (size != sizeof (struct SetKeyMessage))
3508         {
3509           GNUNET_break_op (0);
3510           return;
3511         }
3512       GNUNET_STATISTICS_update (stats, gettext_noop ("# session keys received"), 1, GNUNET_NO);
3513       handle_set_key (n, (const struct SetKeyMessage *) message);
3514       break;
3515     case GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE:
3516       if (size < sizeof (struct EncryptedMessage) +
3517           sizeof (struct GNUNET_MessageHeader))
3518         {
3519           GNUNET_break_op (0);
3520           return;
3521         }
3522       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3523           (n->status != PEER_STATE_KEY_CONFIRMED))
3524         {
3525           GNUNET_break_op (0);
3526           return;
3527         }
3528       handle_encrypted_message (n, (const struct EncryptedMessage *) message);
3529       break;
3530     case GNUNET_MESSAGE_TYPE_CORE_PING:
3531       if (size != sizeof (struct PingMessage))
3532         {
3533           GNUNET_break_op (0);
3534           return;
3535         }
3536       GNUNET_STATISTICS_update (stats, gettext_noop ("# PING messages received"), 1, GNUNET_NO);
3537       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3538           (n->status != PEER_STATE_KEY_CONFIRMED))
3539         {
3540 #if DEBUG_CORE
3541           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3542                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3543                       "PING", GNUNET_i2s (&n->peer));
3544 #endif
3545           GNUNET_free_non_null (n->pending_ping);
3546           n->pending_ping = GNUNET_malloc (sizeof (struct PingMessage));
3547           memcpy (n->pending_ping, message, sizeof (struct PingMessage));
3548           return;
3549         }
3550       handle_ping (n, (const struct PingMessage *) message);
3551       break;
3552     case GNUNET_MESSAGE_TYPE_CORE_PONG:
3553       if (size != sizeof (struct PongMessage))
3554         {
3555           GNUNET_break_op (0);
3556           return;
3557         }
3558       GNUNET_STATISTICS_update (stats, gettext_noop ("# PONG messages received"), 1, GNUNET_NO);
3559       if ( (n->status != PEER_STATE_KEY_RECEIVED) &&
3560            (n->status != PEER_STATE_KEY_CONFIRMED) )
3561         {
3562 #if DEBUG_CORE
3563           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3564                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3565                       "PONG", GNUNET_i2s (&n->peer));
3566 #endif
3567           GNUNET_free_non_null (n->pending_pong);
3568           n->pending_pong = GNUNET_malloc (sizeof (struct PongMessage));
3569           memcpy (n->pending_pong, message, sizeof (struct PongMessage));
3570           return;
3571         }
3572       handle_pong (n, (const struct PongMessage *) message);
3573       break;
3574     default:
3575       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3576                   _("Unsupported message of type %u received.\n"),
3577                   (unsigned int) type);
3578       return;
3579     }
3580   if (n->status == PEER_STATE_KEY_CONFIRMED)
3581     {
3582       now = GNUNET_TIME_absolute_get ();
3583       n->last_activity = now;
3584       if (!up)
3585         {
3586           GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), 1, GNUNET_NO);
3587           n->time_established = now;
3588         }
3589       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3590         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3591       n->keep_alive_task
3592         = GNUNET_SCHEDULER_add_delayed (sched,
3593                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3594                                         &send_keep_alive,
3595                                         n);
3596     }
3597 }
3598
3599
3600 /**
3601  * Function that recalculates the bandwidth quota for the
3602  * given neighbour and transmits it to the transport service.
3603  *
3604  * @param cls neighbour for the quota update
3605  * @param tc context
3606  */
3607 static void
3608 neighbour_quota_update (void *cls,
3609                         const struct GNUNET_SCHEDULER_TaskContext *tc)
3610 {
3611   struct Neighbour *n = cls;
3612   struct GNUNET_BANDWIDTH_Value32NBO q_in;
3613   double pref_rel;
3614   double share;
3615   unsigned long long distributable;
3616   uint64_t need_per_peer;
3617   uint64_t need_per_second;
3618
3619 #if DEBUG_CORE
3620   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3621               "Neighbour quota update calculation running for peer `%4s'\n",
3622               GNUNET_i2s (&n->peer));
3623 #endif
3624   n->quota_update_task = GNUNET_SCHEDULER_NO_TASK;
3625   /* calculate relative preference among all neighbours;
3626      divides by a bit more to avoid division by zero AND to
3627      account for possibility of new neighbours joining any time
3628      AND to convert to double... */
3629   if (preference_sum == 0)
3630     {
3631       pref_rel = 1.0 / (double) neighbour_count;
3632     }
3633   else
3634     {
3635       pref_rel = n->current_preference / preference_sum;
3636     }
3637   need_per_peer = GNUNET_BANDWIDTH_value_get_available_until (MIN_BANDWIDTH_PER_PEER,
3638                                                               GNUNET_TIME_UNIT_SECONDS);
3639   need_per_second = need_per_peer * neighbour_count;
3640   distributable = 0;
3641   if (bandwidth_target_out_bps > need_per_second)
3642     distributable = bandwidth_target_out_bps - need_per_second;
3643   share = distributable * pref_rel;
3644   if (share + need_per_peer > UINT32_MAX)
3645     q_in = GNUNET_BANDWIDTH_value_init (UINT32_MAX);
3646   else
3647     q_in = GNUNET_BANDWIDTH_value_init (need_per_peer + (uint32_t) share);
3648   /* check if we want to disconnect for good due to inactivity */
3649   if ( (GNUNET_TIME_absolute_get_duration (n->last_activity).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) &&
3650        (GNUNET_TIME_absolute_get_duration (n->time_established).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) )
3651     {
3652 #if DEBUG_CORE
3653       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3654                   "Forcing disconnect of `%4s' due to inactivity\n",
3655                   GNUNET_i2s (&n->peer));
3656 #endif
3657       q_in = GNUNET_BANDWIDTH_value_init (0); /* force disconnect */
3658     }
3659 #if DEBUG_CORE_QUOTA
3660   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3661               "Current quota for `%4s' is %u/%llu b/s in (old: %u b/s) / %u out (%u internal)\n",
3662               GNUNET_i2s (&n->peer),
3663               (unsigned int) ntohl (q_in.value__),
3664               bandwidth_target_out_bps,
3665               (unsigned int) ntohl (n->bw_in.value__),
3666               (unsigned int) ntohl (n->bw_out.value__),
3667               (unsigned int) ntohl (n->bw_out_internal_limit.value__));
3668 #endif
3669   if (n->bw_in.value__ != q_in.value__)
3670     {
3671       n->bw_in = q_in;
3672       if (GNUNET_YES == n->is_connected)
3673         GNUNET_TRANSPORT_set_quota (transport,
3674                                     &n->peer,
3675                                     n->bw_in,
3676                                     n->bw_out,
3677                                     GNUNET_TIME_UNIT_FOREVER_REL,
3678                                     NULL, NULL);
3679     }
3680   schedule_quota_update (n);
3681 }
3682
3683
3684 /**
3685  * Function called by transport to notify us that
3686  * a peer connected to us (on the network level).
3687  *
3688  * @param cls closure
3689  * @param peer the peer that connected
3690  * @param latency current latency of the connection
3691  * @param distance in overlay hops, as given by transport plugin
3692  */
3693 static void
3694 handle_transport_notify_connect (void *cls,
3695                                  const struct GNUNET_PeerIdentity *peer,
3696                                  struct GNUNET_TIME_Relative latency,
3697                                  unsigned int distance)
3698 {
3699   struct Neighbour *n;
3700
3701   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3702     {
3703       GNUNET_break (0);
3704       return;
3705     }
3706   n = find_neighbour (peer);
3707   if (n != NULL)
3708     {
3709       if (GNUNET_YES == n->is_connected)
3710         {
3711           /* duplicate connect notification!? */
3712           GNUNET_break (0);
3713           return;
3714         }
3715     }
3716   else
3717     {
3718       n = create_neighbour (peer);
3719     }
3720   GNUNET_STATISTICS_update (stats,
3721                             gettext_noop ("# peers connected (transport)"),
3722                             1,
3723                             GNUNET_NO);
3724   n->is_connected = GNUNET_YES;
3725   n->last_latency = latency;
3726   n->last_distance = distance;
3727   GNUNET_BANDWIDTH_tracker_init (&n->available_send_window,
3728                                  n->bw_out,
3729                                  MAX_WINDOW_TIME_S);
3730   GNUNET_BANDWIDTH_tracker_init (&n->available_recv_window,
3731                                  n->bw_in,
3732                                  MAX_WINDOW_TIME_S);
3733 #if DEBUG_CORE
3734   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3735               "Received connection from `%4s'.\n",
3736               GNUNET_i2s (&n->peer));
3737 #endif
3738   GNUNET_TRANSPORT_set_quota (transport,
3739                               &n->peer,
3740                               n->bw_in,
3741                               n->bw_out,
3742                               GNUNET_TIME_UNIT_FOREVER_REL,
3743                               NULL, NULL);
3744   send_key (n);
3745 }
3746
3747
3748 /**
3749  * Function called by transport telling us that a peer
3750  * disconnected.
3751  *
3752  * @param cls closure
3753  * @param peer the peer that disconnected
3754  */
3755 static void
3756 handle_transport_notify_disconnect (void *cls,
3757                                     const struct GNUNET_PeerIdentity *peer)
3758 {
3759   struct DisconnectNotifyMessage cnm;
3760   struct Neighbour *n;
3761
3762 #if DEBUG_CORE
3763   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3764               "Peer `%4s' disconnected from us.\n", GNUNET_i2s (peer));
3765 #endif
3766   n = find_neighbour (peer);
3767   if (n == NULL)
3768     {
3769       GNUNET_break (0);
3770       return;
3771     }
3772   GNUNET_break (n->is_connected);
3773   cnm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
3774   cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
3775   cnm.peer = *peer;
3776   send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_DISCONNECT);
3777   n->is_connected = GNUNET_NO;
3778   GNUNET_STATISTICS_update (stats,
3779                             gettext_noop ("# peers connected (transport)"),
3780                             -1,
3781                             GNUNET_NO);
3782 }
3783
3784
3785 /**
3786  * Last task run during shutdown.  Disconnects us from
3787  * the transport.
3788  */
3789 static void
3790 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
3791 {
3792   struct Neighbour *n;
3793   struct Client *c;
3794
3795 #if DEBUG_CORE
3796   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3797               "Core service shutting down.\n");
3798 #endif
3799   GNUNET_assert (transport != NULL);
3800   GNUNET_TRANSPORT_disconnect (transport);
3801   transport = NULL;
3802   while (NULL != (n = neighbours))
3803     {
3804       neighbours = n->next;
3805       GNUNET_assert (neighbour_count > 0);
3806       neighbour_count--;
3807       free_neighbour (n);
3808     }
3809   GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), neighbour_count, GNUNET_NO);
3810   GNUNET_SERVER_notification_context_destroy (notifier);
3811   notifier = NULL;
3812   while (NULL != (c = clients))
3813     handle_client_disconnect (NULL, c->client_handle);
3814   if (my_private_key != NULL)
3815     GNUNET_CRYPTO_rsa_key_free (my_private_key);
3816   if (stats != NULL)
3817     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
3818   if (peerinfo != NULL)
3819     GNUNET_PEERINFO_disconnect (peerinfo);
3820 }
3821
3822
3823 /**
3824  * Initiate core service.
3825  *
3826  * @param cls closure
3827  * @param s scheduler to use
3828  * @param serv the initialized server
3829  * @param c configuration to use
3830  */
3831 static void
3832 run (void *cls,
3833      struct GNUNET_SCHEDULER_Handle *s,
3834      struct GNUNET_SERVER_Handle *serv,
3835      const struct GNUNET_CONFIGURATION_Handle *c)
3836 {
3837   char *keyfile;
3838
3839   sched = s;
3840   cfg = c;
3841   /* parse configuration */
3842   if (
3843        (GNUNET_OK !=
3844         GNUNET_CONFIGURATION_get_value_number (c,
3845                                                "CORE",
3846                                                "TOTAL_QUOTA_IN",
3847                                                &bandwidth_target_in_bps)) ||
3848        (GNUNET_OK !=
3849         GNUNET_CONFIGURATION_get_value_number (c,
3850                                                "CORE",
3851                                                "TOTAL_QUOTA_OUT",
3852                                                &bandwidth_target_out_bps)) ||
3853        (GNUNET_OK !=
3854         GNUNET_CONFIGURATION_get_value_filename (c,
3855                                                  "GNUNETD",
3856                                                  "HOSTKEY", &keyfile)))
3857     {
3858       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3859                   _
3860                   ("Core service is lacking key configuration settings.  Exiting.\n"));
3861       GNUNET_SCHEDULER_shutdown (s);
3862       return;
3863     }
3864   peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
3865   if (NULL == peerinfo)
3866     {
3867       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3868                   _("Could not access PEERINFO service.  Exiting.\n"));
3869       GNUNET_SCHEDULER_shutdown (s);
3870       GNUNET_free (keyfile);
3871       return;
3872     }
3873   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
3874   GNUNET_free (keyfile);
3875   if (my_private_key == NULL)
3876     {
3877       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3878                   _("Core service could not access hostkey.  Exiting.\n"));
3879       GNUNET_PEERINFO_disconnect (peerinfo);
3880       GNUNET_SCHEDULER_shutdown (s);
3881       return;
3882     }
3883   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
3884   GNUNET_CRYPTO_hash (&my_public_key,
3885                       sizeof (my_public_key), &my_identity.hashPubKey);
3886   /* setup notification */
3887   server = serv;
3888   notifier = GNUNET_SERVER_notification_context_create (server,
3889                                                         MAX_NOTIFY_QUEUE);
3890   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
3891   /* setup transport connection */
3892   transport = GNUNET_TRANSPORT_connect (sched,
3893                                         cfg,
3894                                         NULL,
3895                                         &handle_transport_receive,
3896                                         &handle_transport_notify_connect,
3897                                         &handle_transport_notify_disconnect);
3898   GNUNET_assert (NULL != transport);
3899   stats = GNUNET_STATISTICS_create (sched, "core", cfg);
3900   GNUNET_SCHEDULER_add_delayed (sched,
3901                                 GNUNET_TIME_UNIT_FOREVER_REL,
3902                                 &cleaning_task, NULL);
3903   /* process client requests */
3904   GNUNET_SERVER_add_handlers (server, handlers);
3905   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3906               _("Core service of `%4s' ready.\n"), GNUNET_i2s (&my_identity));
3907 }
3908
3909
3910
3911 /**
3912  * The main function for the transport service.
3913  *
3914  * @param argc number of arguments from the command line
3915  * @param argv command line arguments
3916  * @return 0 ok, 1 on error
3917  */
3918 int
3919 main (int argc, char *const *argv)
3920 {
3921   return (GNUNET_OK ==
3922           GNUNET_SERVICE_run (argc,
3923                               argv,
3924                               "core",
3925                               GNUNET_SERVICE_OPTION_NONE,
3926                               &run, NULL)) ? 0 : 1;
3927 }
3928
3929 /* end of gnunet-service-core.c */