src/core/gnunet-service-core.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file 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 hmac;
 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 message stream tokenizer (for encrypted payload).
 668  */
 669 static struct GNUNET_SERVER_MessageStreamTokenizer *mst;
 670
 671 /**
 672  * Our configuration.
 673  */
 674 const struct GNUNET_CONFIGURATION_Handle *cfg;
 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  * Function called by transport telling us that a peer
 834  * changed status.
 835  *
 836  * @param peer the peer that changed status
 837  */
 838 static void
 839 handle_peer_status_change (struct Neighbour *n)
 840 {
 841   struct PeerStatusNotifyMessage psnm;
 842
 843   if (! n->is_connected)
 844     return;
 845 #if DEBUG_CORE
 846   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 847               "Peer `%4s' changed status\n",
 848               GNUNET_i2s (&n->peer));
 849 #endif
 850   psnm.header.size = htons (sizeof (struct PeerStatusNotifyMessage));
 851   psnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_STATUS_CHANGE);
 852   psnm.distance = htonl (n->last_distance);
 853   psnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
 854   psnm.timeout = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (n->last_activity,
 855                                                                       GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
 856   psnm.bandwidth_in = n->bw_in;
 857   psnm.bandwidth_out = n->bw_out;
 858   psnm.peer = n->peer;
 859   send_to_all_clients (&psnm.header,
 860                        GNUNET_YES,
 861                        GNUNET_CORE_OPTION_SEND_STATUS_CHANGE);
 862   GNUNET_STATISTICS_update (stats,
 863                             gettext_noop ("# peer status changes"),
 864                             1,
 865                             GNUNET_NO);
 866 }
 867
 868 /**
 869  * Handle CORE_ITERATE_PEERS request.
 870  */
 871 static void
 872 handle_client_iterate_peers (void *cls,
 873                     struct GNUNET_SERVER_Client *client,
 874                     const struct GNUNET_MessageHeader *message)
 875 {
 876   struct Neighbour *n;
 877   struct ConnectNotifyMessage cnm;
 878   struct GNUNET_MessageHeader done_msg;
 879   struct GNUNET_SERVER_TransmitContext *tc;
 880
 881   /* notify new client about existing neighbours */
 882   cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
 883   cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
 884   done_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
 885   done_msg.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
 886   tc = GNUNET_SERVER_transmit_context_create (client);
 887   n = neighbours;
 888   while (n != NULL)
 889     {
 890       if (n->status == PEER_STATE_KEY_CONFIRMED)
 891         {
 892 #if DEBUG_CORE_CLIENT
 893           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 894                       "Sending `%s' message to client.\n", "NOTIFY_CONNECT");
 895 #endif
 896           cnm.distance = htonl (n->last_distance);
 897           cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
 898           cnm.peer = n->peer;
 899           GNUNET_SERVER_transmit_context_append_message (tc, &cnm.header);
 900           /*send_to_client (c, &cnm.header, GNUNET_NO);*/
 901         }
 902       n = n->next;
 903     }
 904
 905   GNUNET_SERVER_transmit_context_append_message (tc, &done_msg);
 906   GNUNET_SERVER_transmit_context_run (tc,
 907                                       GNUNET_TIME_UNIT_FOREVER_REL);
 908 }
 909
 910
 911 /**
 912  * Handle CORE_INIT request.
 913  */
 914 static void
 915 handle_client_init (void *cls,
 916                     struct GNUNET_SERVER_Client *client,
 917                     const struct GNUNET_MessageHeader *message)
 918 {
 919   const struct InitMessage *im;
 920   struct InitReplyMessage irm;
 921   struct Client *c;
 922   uint16_t msize;
 923   const uint16_t *types;
 924   uint16_t *wtypes;
 925   struct Neighbour *n;
 926   struct ConnectNotifyMessage cnm;
 927   unsigned int i;
 928
 929 #if DEBUG_CORE_CLIENT
 930   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 931               "Client connecting to core service with `%s' message\n",
 932               "INIT");
 933 #endif
 934   /* check that we don't have an entry already */
 935   c = clients;
 936   while (c != NULL)
 937     {
 938       if (client == c->client_handle)
 939         {
 940           GNUNET_break (0);
 941           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 942           return;
 943         }
 944       c = c->next;
 945     }
 946   msize = ntohs (message->size);
 947   if (msize < sizeof (struct InitMessage))
 948     {
 949       GNUNET_break (0);
 950       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 951       return;
 952     }
 953   GNUNET_SERVER_notification_context_add (notifier, client);
 954   im = (const struct InitMessage *) message;
 955   types = (const uint16_t *) &im[1];
 956   msize -= sizeof (struct InitMessage);
 957   c = GNUNET_malloc (sizeof (struct Client) + msize);
 958   c->client_handle = client;
 959   c->next = clients;
 960   clients = c;
 961   c->tcnt = msize / sizeof (uint16_t);
 962   c->types = (const uint16_t *) &c[1];
 963   wtypes = (uint16_t *) &c[1];
 964   for (i=0;i<c->tcnt;i++)
 965     wtypes[i] = ntohs (types[i]);
 966   c->options = ntohl (im->options);
 967 #if DEBUG_CORE_CLIENT
 968   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 969               "Client %p is interested in %u message types\n",
 970               c,
 971               (unsigned int) c->tcnt);
 972 #endif
 973   /* send init reply message */
 974   irm.header.size = htons (sizeof (struct InitReplyMessage));
 975   irm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY);
 976   irm.reserved = htonl (0);
 977   memcpy (&irm.publicKey,
 978           &my_public_key,
 979           sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
 980 #if DEBUG_CORE_CLIENT
 981   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 982               "Sending `%s' message to client.\n", "INIT_REPLY");
 983 #endif
 984   send_to_client (c, &irm.header, GNUNET_NO);
 985   if (0 != (c->options & GNUNET_CORE_OPTION_SEND_CONNECT))
 986     {
 987       /* notify new client about existing neighbours */
 988       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
 989       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
 990       n = neighbours;
 991       while (n != NULL)
 992         {
 993           if (n->status == PEER_STATE_KEY_CONFIRMED)
 994             {
 995 #if DEBUG_CORE_CLIENT
 996               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 997                           "Sending `%s' message to client.\n", "NOTIFY_CONNECT");
 998 #endif
 999               cnm.distance = htonl (n->last_distance);
1000               cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
1001               cnm.peer = n->peer;
1002               send_to_client (c, &cnm.header, GNUNET_NO);
1003             }
1004           n = n->next;
1005         }
1006     }
1007   GNUNET_SERVER_receive_done (client, GNUNET_OK);
1008 }
1009
1010
1011 /**
1012  * A client disconnected, clean up.
1013  *
1014  * @param cls closure
1015  * @param client identification of the client
1016  */
1017 static void
1018 handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
1019 {
1020   struct Client *pos;
1021   struct Client *prev;
1022
1023   if (client == NULL)
1024     return;
1025 #if DEBUG_CORE_CLIENT
1026   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1027               "Client %p has disconnected from core service.\n",
1028               client);
1029 #endif
1030   prev = NULL;
1031   pos = clients;
1032   while (pos != NULL)
1033     {
1034       if (client == pos->client_handle)
1035         {
1036           if (prev == NULL)
1037             clients = pos->next;
1038           else
1039             prev->next = pos->next;
1040           GNUNET_free (pos);
1041           return;
1042         }
1043       prev = pos;
1044       pos = pos->next;
1045     }
1046   /* client never sent INIT */
1047 }
1048
1049
1050 /**
1051  * Handle REQUEST_INFO request.
1052  */
1053 static void
1054 handle_client_request_info (void *cls,
1055                             struct GNUNET_SERVER_Client *client,
1056                             const struct GNUNET_MessageHeader *message)
1057 {
1058   const struct RequestInfoMessage *rcm;
1059   struct Neighbour *n;
1060   struct ConfigurationInfoMessage cim;
1061   int32_t want_reserv;
1062   int32_t got_reserv;
1063   unsigned long long old_preference;
1064   struct GNUNET_SERVER_TransmitContext *tc;
1065
1066 #if DEBUG_CORE_CLIENT
1067   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1068               "Core service receives `%s' request.\n", "REQUEST_INFO");
1069 #endif
1070   rcm = (const struct RequestInfoMessage *) message;
1071   n = find_neighbour (&rcm->peer);
1072   memset (&cim, 0, sizeof (cim));
1073   if (n != NULL)
1074     {
1075       want_reserv = ntohl (rcm->reserve_inbound);
1076       if (n->bw_out_internal_limit.value__ != rcm->limit_outbound.value__)
1077         {
1078           n->bw_out_internal_limit = rcm->limit_outbound;
1079           if (n->bw_out.value__ != GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
1080                                                                n->bw_out_external_limit).value__)
1081             {
1082               n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_internal_limit,
1083                                                       n->bw_out_external_limit);
1084               GNUNET_BANDWIDTH_tracker_update_quota (&n->available_recv_window,
1085                                                      n->bw_out);
1086               GNUNET_TRANSPORT_set_quota (transport,
1087                                           &n->peer,
1088                                           n->bw_in,
1089                                           n->bw_out,
1090                                           GNUNET_TIME_UNIT_FOREVER_REL,
1091                                           NULL, NULL);
1092               handle_peer_status_change (n);
1093             }
1094         }
1095       if (want_reserv < 0)
1096         {
1097           got_reserv = want_reserv;
1098         }
1099       else if (want_reserv > 0)
1100         {
1101           if (GNUNET_BANDWIDTH_tracker_get_delay (&n->available_recv_window,
1102                                                   want_reserv).value == 0)
1103             got_reserv = want_reserv;
1104           else
1105             got_reserv = 0; /* all or nothing */
1106         }
1107       else
1108         got_reserv = 0;
1109       GNUNET_BANDWIDTH_tracker_consume (&n->available_recv_window,
1110                                         got_reserv);
1111       old_preference = n->current_preference;
1112       n->current_preference += GNUNET_ntohll(rcm->preference_change);
1113       if (old_preference > n->current_preference)
1114         {
1115           /* overflow; cap at maximum value */
1116           n->current_preference = ULLONG_MAX;
1117         }
1118       update_preference_sum (n->current_preference - old_preference);
1119 #if DEBUG_CORE_QUOTA
1120       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1121                   "Received reservation request for %d bytes for peer `%4s', reserved %d bytes\n",
1122                   (int) want_reserv,
1123                   GNUNET_i2s (&rcm->peer),
1124                   (int) got_reserv);
1125 #endif
1126       cim.reserved_amount = htonl (got_reserv);
1127       cim.bw_in = n->bw_in;
1128       cim.bw_out = n->bw_out;
1129       cim.preference = n->current_preference;
1130     }
1131   cim.header.size = htons (sizeof (struct ConfigurationInfoMessage));
1132   cim.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO);
1133   cim.peer = rcm->peer;
1134
1135 #if DEBUG_CORE_CLIENT
1136   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1137               "Sending `%s' message to client.\n", "CONFIGURATION_INFO");
1138 #endif
1139   tc = GNUNET_SERVER_transmit_context_create (client);
1140   GNUNET_SERVER_transmit_context_append_message (tc, &cim.header);
1141   GNUNET_SERVER_transmit_context_run (tc,
1142                                       GNUNET_TIME_UNIT_FOREVER_REL);
1143 }
1144
1145
1146 /**
1147  * Free the given entry for the neighbour (it has
1148  * already been removed from the list at this point).
1149  *
1150  * @param n neighbour to free
1151  */
1152 static void
1153 free_neighbour (struct Neighbour *n)
1154 {
1155   struct MessageEntry *m;
1156
1157 #if DEBUG_CORE
1158   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1159               "Destroying neighbour entry for peer `%4s'\n",
1160               GNUNET_i2s (&n->peer));
1161 #endif
1162   if (n->pitr != NULL)
1163     {
1164       GNUNET_PEERINFO_iterate_cancel (n->pitr);
1165       n->pitr = NULL;
1166     }
1167   if (n->skm != NULL)
1168     {
1169       GNUNET_free (n->skm);
1170       n->skm = NULL;
1171     }
1172   while (NULL != (m = n->messages))
1173     {
1174       n->messages = m->next;
1175       GNUNET_free (m);
1176     }
1177   while (NULL != (m = n->encrypted_head))
1178     {
1179       GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
1180                                    n->encrypted_tail,
1181                                    m);
1182       GNUNET_free (m);
1183     }
1184   if (NULL != n->th)
1185     {
1186       GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
1187       n->th = NULL;
1188     }
1189   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
1190     GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
1191   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
1192     GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
1193   if (n->quota_update_task != GNUNET_SCHEDULER_NO_TASK)
1194     GNUNET_SCHEDULER_cancel (sched, n->quota_update_task);
1195   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
1196     GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
1197   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
1198       GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
1199   if (n->status == PEER_STATE_KEY_CONFIRMED)
1200     GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), -1, GNUNET_NO);
1201   GNUNET_free_non_null (n->public_key);
1202   GNUNET_free_non_null (n->pending_ping);
1203   GNUNET_free_non_null (n->pending_pong);
1204   GNUNET_free (n);
1205 }
1206
1207
1208 /**
1209  * Check if we have encrypted messages for the specified neighbour
1210  * pending, and if so, check with the transport about sending them
1211  * out.
1212  *
1213  * @param n neighbour to check.
1214  */
1215 static void process_encrypted_neighbour_queue (struct Neighbour *n);
1216
1217
1218 /**
1219  * Encrypt size bytes from in and write the result to out.  Use the
1220  * key for outbound traffic of the given neighbour.
1221  *
1222  * @param n neighbour we are sending to
1223  * @param iv initialization vector to use
1224  * @param in ciphertext
1225  * @param out plaintext
1226  * @param size size of in/out
1227  * @return GNUNET_OK on success
1228  */
1229 static int
1230 do_encrypt (struct Neighbour *n,
1231             const GNUNET_HashCode * iv,
1232             const void *in, void *out, size_t size)
1233 {
1234   if (size != (uint16_t) size)
1235     {
1236       GNUNET_break (0);
1237       return GNUNET_NO;
1238     }
1239   GNUNET_assert (size ==
1240                  GNUNET_CRYPTO_aes_encrypt (in,
1241                                             (uint16_t) size,
1242                                             &n->encrypt_key,
1243                                             (const struct
1244                                              GNUNET_CRYPTO_AesInitializationVector
1245                                              *) iv, out));
1246   GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes encrypted"), size, GNUNET_NO);
1247 #if DEBUG_CORE
1248   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1249               "Encrypted %u bytes for `%4s' using key %u\n",
1250               (unsigned int) size,
1251               GNUNET_i2s (&n->peer),
1252               (unsigned int) n->encrypt_key.crc32);
1253 #endif
1254   return GNUNET_OK;
1255 }
1256
1257
1258 /**
1259  * Consider freeing the given neighbour since we may not need
1260  * to keep it around anymore.
1261  *
1262  * @param n neighbour to consider discarding
1263  */
1264 static void
1265 consider_free_neighbour (struct Neighbour *n);
1266
1267
1268 /**
1269  * Task triggered when a neighbour entry is about to time out
1270  * (and we should prevent this by sending a PING).
1271  *
1272  * @param cls the 'struct Neighbour'
1273  * @param tc scheduler context (not used)
1274  */
1275 static void
1276 send_keep_alive (void *cls,
1277                  const struct GNUNET_SCHEDULER_TaskContext *tc)
1278 {
1279   struct Neighbour *n = cls;
1280   struct GNUNET_TIME_Relative retry;
1281   struct GNUNET_TIME_Relative left;
1282   struct MessageEntry *me;
1283   struct PingMessage pp;
1284   struct PingMessage *pm;
1285
1286   n->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
1287   /* send PING */
1288   me = GNUNET_malloc (sizeof (struct MessageEntry) +
1289                       sizeof (struct PingMessage));
1290   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PING_DELAY);
1291   me->priority = PING_PRIORITY;
1292   me->size = sizeof (struct PingMessage);
1293   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
1294                                      n->encrypted_tail,
1295                                      n->encrypted_tail,
1296                                      me);
1297   pm = (struct PingMessage *) &me[1];
1298   pm->header.size = htons (sizeof (struct PingMessage));
1299   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
1300   pp.challenge = htonl (n->ping_challenge);
1301   pp.target = n->peer;
1302 #if DEBUG_HANDSHAKE
1303   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1304               "Encrypting `%s' message with challenge %u for `%4s' using key %u.\n",
1305               "PING",
1306               (unsigned int) n->ping_challenge,
1307               GNUNET_i2s (&n->peer),
1308               (unsigned int) n->encrypt_key.crc32);
1309 #endif
1310   do_encrypt (n,
1311               &n->peer.hashPubKey,
1312               &pp.challenge,
1313               &pm->challenge,
1314               sizeof (struct PingMessage) -
1315               sizeof (struct GNUNET_MessageHeader));
1316   process_encrypted_neighbour_queue (n);
1317   /* reschedule PING job */
1318   left = GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (n->last_activity,
1319                                                                        GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
1320   retry = GNUNET_TIME_relative_max (GNUNET_TIME_relative_divide (left, 2),
1321                                     MIN_PING_FREQUENCY);
1322   n->keep_alive_task
1323     = GNUNET_SCHEDULER_add_delayed (sched,
1324                                     retry,
1325                                     &send_keep_alive,
1326                                     n);
1327
1328 }
1329
1330
1331 /**
1332  * Task triggered when a neighbour entry might have gotten stale.
1333  *
1334  * @param cls the 'struct Neighbour'
1335  * @param tc scheduler context (not used)
1336  */
1337 static void
1338 consider_free_task (void *cls,
1339                     const struct GNUNET_SCHEDULER_TaskContext *tc)
1340 {
1341   struct Neighbour *n = cls;
1342
1343   n->dead_clean_task = GNUNET_SCHEDULER_NO_TASK;
1344   consider_free_neighbour (n);
1345 }
1346
1347
1348 /**
1349  * Consider freeing the given neighbour since we may not need
1350  * to keep it around anymore.
1351  *
1352  * @param n neighbour to consider discarding
1353  */
1354 static void
1355 consider_free_neighbour (struct Neighbour *n)
1356 {
1357   struct Neighbour *pos;
1358   struct Neighbour *prev;
1359   struct GNUNET_TIME_Relative left;
1360
1361   if ( (n->th != NULL) ||
1362        (n->pitr != NULL) ||
1363        (GNUNET_YES == n->is_connected) )
1364     return; /* no chance */
1365
1366   left = GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (n->last_activity,
1367                                                                        GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
1368   if (left.value > 0)
1369     {
1370       if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
1371         GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
1372       n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
1373                                                          left,
1374                                                          &consider_free_task,
1375                                                          n);
1376       return;
1377     }
1378   /* actually free the neighbour... */
1379   prev = NULL;
1380   pos = neighbours;
1381   while (pos != n)
1382     {
1383       prev = pos;
1384       pos = pos->next;
1385     }
1386   if (prev == NULL)
1387     neighbours = n->next;
1388   else
1389     prev->next = n->next;
1390   GNUNET_assert (neighbour_count > 0);
1391   neighbour_count--;
1392   GNUNET_STATISTICS_set (stats,
1393                          gettext_noop ("# neighbour entries allocated"),
1394                          neighbour_count,
1395                          GNUNET_NO);
1396   free_neighbour (n);
1397 }
1398
1399
1400 /**
1401  * Function called when the transport service is ready to
1402  * receive an encrypted message for the respective peer
1403  *
1404  * @param cls neighbour to use message from
1405  * @param size number of bytes we can transmit
1406  * @param buf where to copy the message
1407  * @return number of bytes transmitted
1408  */
1409 static size_t
1410 notify_encrypted_transmit_ready (void *cls, size_t size, void *buf)
1411 {
1412   struct Neighbour *n = cls;
1413   struct MessageEntry *m;
1414   size_t ret;
1415   char *cbuf;
1416
1417   n->th = NULL;
1418   m = n->encrypted_head;
1419   if (m == NULL)
1420     {
1421 #if DEBUG_CORE
1422       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1423                   "Encrypted message queue empty, no messages added to buffer for `%4s'\n",
1424                   GNUNET_i2s (&n->peer));
1425 #endif
1426       return 0;
1427     }
1428   GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
1429                                n->encrypted_tail,
1430                                m);
1431   ret = 0;
1432   cbuf = buf;
1433   if (buf != NULL)
1434     {
1435       GNUNET_assert (size >= m->size);
1436       memcpy (cbuf, &m[1], m->size);
1437       ret = m->size;
1438       GNUNET_BANDWIDTH_tracker_consume (&n->available_send_window,
1439                                         m->size);
1440 #if DEBUG_CORE
1441       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1442                   "Copied message of type %u and size %u into transport buffer for `%4s'\n",
1443                   (unsigned int) ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
1444                   (unsigned int) ret,
1445                   GNUNET_i2s (&n->peer));
1446 #endif
1447       process_encrypted_neighbour_queue (n);
1448     }
1449   else
1450     {
1451 #if DEBUG_CORE
1452       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1453                   "Transmission of message of type %u and size %u failed\n",
1454                   (unsigned int) ntohs (((struct GNUNET_MessageHeader *) &m[1])->type),
1455                   (unsigned int) m->size);
1456 #endif
1457     }
1458   GNUNET_free (m);
1459   consider_free_neighbour (n);
1460   return ret;
1461 }
1462
1463
1464 /**
1465  * Check if we have plaintext messages for the specified neighbour
1466  * pending, and if so, consider batching and encrypting them (and
1467  * then trigger processing of the encrypted queue if needed).
1468  *
1469  * @param n neighbour to check.
1470  */
1471 static void process_plaintext_neighbour_queue (struct Neighbour *n);
1472
1473
1474 /**
1475  * Check if we have encrypted messages for the specified neighbour
1476  * pending, and if so, check with the transport about sending them
1477  * out.
1478  *
1479  * @param n neighbour to check.
1480  */
1481 static void
1482 process_encrypted_neighbour_queue (struct Neighbour *n)
1483 {
1484   struct MessageEntry *m;
1485
1486   if (n->th != NULL)
1487     return;  /* request already pending */
1488   m = n->encrypted_head;
1489   if (m == NULL)
1490     {
1491       /* encrypted queue empty, try plaintext instead */
1492       process_plaintext_neighbour_queue (n);
1493       return;
1494     }
1495 #if DEBUG_CORE
1496   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1497               "Asking transport for transmission of %u bytes to `%4s' in next %llu ms\n",
1498               (unsigned int) m->size,
1499               GNUNET_i2s (&n->peer),
1500               (unsigned long long) GNUNET_TIME_absolute_get_remaining (m->deadline).
1501               value);
1502 #endif
1503   n->th =
1504     GNUNET_TRANSPORT_notify_transmit_ready (transport, &n->peer,
1505                                             m->size,
1506                                             m->priority,
1507                                             GNUNET_TIME_absolute_get_remaining
1508                                             (m->deadline),
1509                                             &notify_encrypted_transmit_ready,
1510                                             n);
1511   if (n->th == NULL)
1512     {
1513       /* message request too large or duplicate request */
1514       GNUNET_break (0);
1515       /* discard encrypted message */
1516       GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
1517                                    n->encrypted_tail,
1518                                    m);
1519       GNUNET_free (m);
1520       process_encrypted_neighbour_queue (n);
1521     }
1522 }
1523
1524
1525 /**
1526  * Decrypt size bytes from in and write the result to out.  Use the
1527  * key for inbound traffic of the given neighbour.  This function does
1528  * NOT do any integrity-checks on the result.
1529  *
1530  * @param n neighbour we are receiving from
1531  * @param iv initialization vector to use
1532  * @param in ciphertext
1533  * @param out plaintext
1534  * @param size size of in/out
1535  * @return GNUNET_OK on success
1536  */
1537 static int
1538 do_decrypt (struct Neighbour *n,
1539             const GNUNET_HashCode * iv,
1540             const void *in, void *out, size_t size)
1541 {
1542   if (size != (uint16_t) size)
1543     {
1544       GNUNET_break (0);
1545       return GNUNET_NO;
1546     }
1547   if ((n->status != PEER_STATE_KEY_RECEIVED) &&
1548       (n->status != PEER_STATE_KEY_CONFIRMED))
1549     {
1550       GNUNET_break_op (0);
1551       return GNUNET_SYSERR;
1552     }
1553   if (size !=
1554       GNUNET_CRYPTO_aes_decrypt (in,
1555                                  (uint16_t) size,
1556                                  &n->decrypt_key,
1557                                  (const struct
1558                                   GNUNET_CRYPTO_AesInitializationVector *) iv,
1559                                  out))
1560     {
1561       GNUNET_break (0);
1562       return GNUNET_SYSERR;
1563     }
1564   GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes decrypted"), size, GNUNET_NO);
1565 #if DEBUG_CORE
1566   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1567               "Decrypted %u bytes from `%4s' using key %u\n",
1568               (unsigned int) size,
1569               GNUNET_i2s (&n->peer),
1570               (unsigned int) n->decrypt_key.crc32);
1571 #endif
1572   return GNUNET_OK;
1573 }
1574
1575
1576 /**
1577  * Select messages for transmission.  This heuristic uses a combination
1578  * of earliest deadline first (EDF) scheduling (with bounded horizon)
1579  * and priority-based discard (in case no feasible schedule exist) and
1580  * speculative optimization (defer any kind of transmission until
1581  * we either create a batch of significant size, 25% of max, or until
1582  * we are close to a deadline).  Furthermore, when scheduling the
1583  * heuristic also packs as many messages into the batch as possible,
1584  * starting with those with the earliest deadline.  Yes, this is fun.
1585  *
1586  * @param n neighbour to select messages from
1587  * @param size number of bytes to select for transmission
1588  * @param retry_time set to the time when we should try again
1589  *        (only valid if this function returns zero)
1590  * @return number of bytes selected, or 0 if we decided to
1591  *         defer scheduling overall; in that case, retry_time is set.
1592  */
1593 static size_t
1594 select_messages (struct Neighbour *n,
1595                  size_t size, struct GNUNET_TIME_Relative *retry_time)
1596 {
1597   struct MessageEntry *pos;
1598   struct MessageEntry *min;
1599   struct MessageEntry *last;
1600   unsigned int min_prio;
1601   struct GNUNET_TIME_Absolute t;
1602   struct GNUNET_TIME_Absolute now;
1603   struct GNUNET_TIME_Relative delta;
1604   uint64_t avail;
1605   struct GNUNET_TIME_Relative slack;     /* how long could we wait before missing deadlines? */
1606   size_t off;
1607   uint64_t tsize;
1608   unsigned int queue_size;
1609   int discard_low_prio;
1610
1611   GNUNET_assert (NULL != n->messages);
1612   now = GNUNET_TIME_absolute_get ();
1613   /* last entry in linked list of messages processed */
1614   last = NULL;
1615   /* should we remove the entry with the lowest
1616      priority from consideration for scheduling at the
1617      end of the loop? */
1618   queue_size = 0;
1619   tsize = 0;
1620   pos = n->messages;
1621   while (pos != NULL)
1622     {
1623       queue_size++;
1624       tsize += pos->size;
1625       pos = pos->next;
1626     }
1627   discard_low_prio = GNUNET_YES;
1628   while (GNUNET_YES == discard_low_prio)
1629     {
1630       min = NULL;
1631       min_prio = UINT_MAX;
1632       discard_low_prio = GNUNET_NO;
1633       /* calculate number of bytes available for transmission at time "t" */
1634       avail = GNUNET_BANDWIDTH_tracker_get_available (&n->available_send_window);
1635       t = now;
1636       /* how many bytes have we (hypothetically) scheduled so far */
1637       off = 0;
1638       /* maximum time we can wait before transmitting anything
1639          and still make all of our deadlines */
1640       slack = GNUNET_TIME_UNIT_FOREVER_REL;
1641       pos = n->messages;
1642       /* note that we use "*2" here because we want to look
1643          a bit further into the future; much more makes no
1644          sense since new message might be scheduled in the
1645          meantime... */
1646       while ((pos != NULL) && (off < size * 2))
1647         {
1648           if (pos->do_transmit == GNUNET_YES)
1649             {
1650               /* already removed from consideration */
1651               pos = pos->next;
1652               continue;
1653             }
1654           if (discard_low_prio == GNUNET_NO)
1655             {
1656               delta = GNUNET_TIME_absolute_get_difference (t, pos->deadline);
1657               if (delta.value > 0)
1658                 {
1659                   // FIXME: HUH? Check!
1660                   t = pos->deadline;
1661                   avail += GNUNET_BANDWIDTH_value_get_available_until (n->bw_out,
1662                                                                        delta);
1663                 }
1664               if (avail < pos->size)
1665                 {
1666                   // FIXME: HUH? Check!
1667                   discard_low_prio = GNUNET_YES;        /* we could not schedule this one! */
1668                 }
1669               else
1670                 {
1671                   avail -= pos->size;
1672                   /* update slack, considering both its absolute deadline
1673                      and relative deadlines caused by other messages
1674                      with their respective load */
1675                   slack = GNUNET_TIME_relative_min (slack,
1676                                                     GNUNET_BANDWIDTH_value_get_delay_for (n->bw_out,
1677                                                                                           avail));
1678                   if (pos->deadline.value <= now.value)
1679                     {
1680                       /* now or never */
1681                       slack = GNUNET_TIME_UNIT_ZERO;
1682                     }
1683                   else if (GNUNET_YES == pos->got_slack)
1684                     {
1685                       /* should be soon now! */
1686                       slack = GNUNET_TIME_relative_min (slack,
1687                                                         GNUNET_TIME_absolute_get_remaining (pos->slack_deadline));
1688                     }
1689                   else
1690                     {
1691                       slack =
1692                         GNUNET_TIME_relative_min (slack,
1693                                                   GNUNET_TIME_absolute_get_difference (now, pos->deadline));
1694                       pos->got_slack = GNUNET_YES;
1695                       pos->slack_deadline = GNUNET_TIME_absolute_min (pos->deadline,
1696                                                                       GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_MAX_CORK_DELAY));
1697                     }
1698                 }
1699             }
1700           off += pos->size;
1701           t = GNUNET_TIME_absolute_max (pos->deadline, t); // HUH? Check!
1702           if (pos->priority <= min_prio)
1703             {
1704               /* update min for discard */
1705               min_prio = pos->priority;
1706               min = pos;
1707             }
1708           pos = pos->next;
1709         }
1710       if (discard_low_prio)
1711         {
1712           GNUNET_assert (min != NULL);
1713           /* remove lowest-priority entry from consideration */
1714           min->do_transmit = GNUNET_YES;        /* means: discard (for now) */
1715         }
1716       last = pos;
1717     }
1718   /* guard against sending "tiny" messages with large headers without
1719      urgent deadlines */
1720   if ( (slack.value > GNUNET_CONSTANTS_MAX_CORK_DELAY.value) &&
1721        (size > 4 * off) &&
1722        (queue_size <= MAX_PEER_QUEUE_SIZE - 2) )
1723     {
1724       /* less than 25% of message would be filled with deadlines still
1725          being met if we delay by one second or more; so just wait for
1726          more data; but do not wait longer than 1s (since we don't want
1727          to delay messages for a really long time either). */
1728       *retry_time = GNUNET_CONSTANTS_MAX_CORK_DELAY;
1729       /* reset do_transmit values for next time */
1730       while (pos != last)
1731         {
1732           pos->do_transmit = GNUNET_NO;
1733           pos = pos->next;
1734         }
1735 #if DEBUG_CORE
1736       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1737                   "Deferring transmission for %llums due to underfull message buffer size (%u/%u)\n",
1738                   (unsigned long long) retry_time->value,
1739                   (unsigned int) off,
1740                   (unsigned int) size);
1741 #endif
1742       return 0;
1743     }
1744   /* select marked messages (up to size) for transmission */
1745   off = 0;
1746   pos = n->messages;
1747   while (pos != last)
1748     {
1749       if ((pos->size <= size) && (pos->do_transmit == GNUNET_NO))
1750         {
1751           pos->do_transmit = GNUNET_YES;        /* mark for transmission */
1752           off += pos->size;
1753           size -= pos->size;
1754 #if DEBUG_CORE
1755           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1756                       "Selecting message of size %u for transmission\n",
1757                       (unsigned int) pos->size);
1758 #endif
1759         }
1760       else
1761         {
1762 #if DEBUG_CORE
1763           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1764                       "Not selecting message of size %u for transmission at this time (maximum is %u)\n",
1765                       (unsigned int) pos->size,
1766                       size);
1767 #endif
1768           pos->do_transmit = GNUNET_NO;   /* mark for not transmitting! */
1769         }
1770       pos = pos->next;
1771     }
1772 #if DEBUG_CORE
1773   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1774               "Selected %llu/%llu bytes of %u/%u plaintext messages for transmission to `%4s'.\n",
1775               (unsigned long long) off, (unsigned long long) tsize,
1776               queue_size, (unsigned int) MAX_PEER_QUEUE_SIZE,
1777               GNUNET_i2s (&n->peer));
1778 #endif
1779   return off;
1780 }
1781
1782
1783 /**
1784  * Batch multiple messages into a larger buffer.
1785  *
1786  * @param n neighbour to take messages from
1787  * @param buf target buffer
1788  * @param size size of buf
1789  * @param deadline set to transmission deadline for the result
1790  * @param retry_time set to the time when we should try again
1791  *        (only valid if this function returns zero)
1792  * @param priority set to the priority of the batch
1793  * @return number of bytes written to buf (can be zero)
1794  */
1795 static size_t
1796 batch_message (struct Neighbour *n,
1797                char *buf,
1798                size_t size,
1799                struct GNUNET_TIME_Absolute *deadline,
1800                struct GNUNET_TIME_Relative *retry_time,
1801                unsigned int *priority)
1802 {
1803   char ntmb[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
1804   struct NotifyTrafficMessage *ntm = (struct NotifyTrafficMessage*) ntmb;
1805   struct MessageEntry *pos;
1806   struct MessageEntry *prev;
1807   struct MessageEntry *next;
1808   size_t ret;
1809
1810   ret = 0;
1811   *priority = 0;
1812   *deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
1813   *retry_time = GNUNET_TIME_UNIT_FOREVER_REL;
1814   if (0 == select_messages (n, size, retry_time))
1815     {
1816 #if DEBUG_CORE
1817       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1818                   "No messages selected, will try again in %llu ms\n",
1819                   retry_time->value);
1820 #endif
1821       return 0;
1822     }
1823   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND);
1824   ntm->distance = htonl (n->last_distance);
1825   ntm->latency = GNUNET_TIME_relative_hton (n->last_latency);
1826   ntm->peer = n->peer;
1827   pos = n->messages;
1828   prev = NULL;
1829   while ((pos != NULL) && (size >= sizeof (struct GNUNET_MessageHeader)))
1830     {
1831       next = pos->next;
1832       if (GNUNET_YES == pos->do_transmit)
1833         {
1834           GNUNET_assert (pos->size <= size);
1835           /* do notifications */
1836           /* FIXME: track if we have *any* client that wants
1837              full notifications and only do this if that is
1838              actually true */
1839           if (pos->size < GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (struct NotifyTrafficMessage))
1840             {
1841               memcpy (&ntm[1], &pos[1], pos->size);
1842               ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) +
1843                                         sizeof (struct GNUNET_MessageHeader));
1844               send_to_all_clients (&ntm->header,
1845                                    GNUNET_YES,
1846                                    GNUNET_CORE_OPTION_SEND_HDR_OUTBOUND);
1847             }
1848           else
1849             {
1850               /* message too large for 'full' notifications, we do at
1851                  least the 'hdr' type */
1852               memcpy (&ntm[1],
1853                       &pos[1],
1854                       sizeof (struct GNUNET_MessageHeader));
1855             }
1856           ntm->header.size = htons (sizeof (struct NotifyTrafficMessage) +
1857                                     pos->size);
1858           send_to_all_clients (&ntm->header,
1859                                GNUNET_YES,
1860                                GNUNET_CORE_OPTION_SEND_FULL_OUTBOUND);
1861 #if DEBUG_HANDSHAKE
1862           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1863                       "Encrypting %u bytes with message of type %u and size %u\n",
1864                       pos->size,
1865                       (unsigned int) ntohs(((const struct GNUNET_MessageHeader*)&pos[1])->type),
1866                       (unsigned int) ntohs(((const struct GNUNET_MessageHeader*)&pos[1])->size));
1867 #endif
1868           /* copy for encrypted transmission */
1869           memcpy (&buf[ret], &pos[1], pos->size);
1870           ret += pos->size;
1871           size -= pos->size;
1872           *priority += pos->priority;
1873 #if DEBUG_CORE
1874           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1875                       "Adding plaintext message of size %u with deadline %llu ms to batch\n",
1876                       (unsigned int) pos->size,
1877                       (unsigned long long) GNUNET_TIME_absolute_get_remaining (pos->deadline).value);
1878 #endif
1879           deadline->value = GNUNET_MIN (deadline->value, pos->deadline.value);
1880           GNUNET_free (pos);
1881           if (prev == NULL)
1882             n->messages = next;
1883           else
1884             prev->next = next;
1885         }
1886       else
1887         {
1888           prev = pos;
1889         }
1890       pos = next;
1891     }
1892 #if DEBUG_CORE
1893   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1894               "Deadline for message batch is %llu ms\n",
1895               GNUNET_TIME_absolute_get_remaining (*deadline).value);
1896 #endif
1897   return ret;
1898 }
1899
1900
1901 /**
1902  * Remove messages with deadlines that have long expired from
1903  * the queue.
1904  *
1905  * @param n neighbour to inspect
1906  */
1907 static void
1908 discard_expired_messages (struct Neighbour *n)
1909 {
1910   struct MessageEntry *prev;
1911   struct MessageEntry *next;
1912   struct MessageEntry *pos;
1913   struct GNUNET_TIME_Absolute now;
1914   struct GNUNET_TIME_Relative delta;
1915
1916   now = GNUNET_TIME_absolute_get ();
1917   prev = NULL;
1918   pos = n->messages;
1919   while (pos != NULL)
1920     {
1921       next = pos->next;
1922       delta = GNUNET_TIME_absolute_get_difference (pos->deadline, now);
1923       if (delta.value > PAST_EXPIRATION_DISCARD_TIME.value)
1924         {
1925 #if DEBUG_CORE
1926           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1927                       "Message is %llu ms past due, discarding.\n",
1928                       delta.value);
1929 #endif
1930           if (prev == NULL)
1931             n->messages = next;
1932           else
1933             prev->next = next;
1934           GNUNET_free (pos);
1935         }
1936       else
1937         prev = pos;
1938       pos = next;
1939     }
1940 }
1941
1942
1943 /**
1944  * Signature of the main function of a task.
1945  *
1946  * @param cls closure
1947  * @param tc context information (why was this task triggered now)
1948  */
1949 static void
1950 retry_plaintext_processing (void *cls,
1951                             const struct GNUNET_SCHEDULER_TaskContext *tc)
1952 {
1953   struct Neighbour *n = cls;
1954
1955   n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
1956   process_plaintext_neighbour_queue (n);
1957 }
1958
1959
1960 /**
1961  * Send our key (and encrypted PING) to the other peer.
1962  *
1963  * @param n the other peer
1964  */
1965 static void send_key (struct Neighbour *n);
1966
1967 /**
1968  * Task that will retry "send_key" if our previous attempt failed
1969  * to yield a PONG.
1970  */
1971 static void
1972 set_key_retry_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1973 {
1974   struct Neighbour *n = cls;
1975
1976 #if DEBUG_CORE
1977   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1978               "Retrying key transmission to `%4s'\n",
1979               GNUNET_i2s (&n->peer));
1980 #endif
1981   n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
1982   n->set_key_retry_frequency =
1983     GNUNET_TIME_relative_multiply (n->set_key_retry_frequency, 2);
1984   send_key (n);
1985 }
1986
1987
1988 /**
1989  * Check if we have plaintext messages for the specified neighbour
1990  * pending, and if so, consider batching and encrypting them (and
1991  * then trigger processing of the encrypted queue if needed).
1992  *
1993  * @param n neighbour to check.
1994  */
1995 static void
1996 process_plaintext_neighbour_queue (struct Neighbour *n)
1997 {
1998   char pbuf[GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE + sizeof (struct EncryptedMessage)];        /* plaintext */
1999   size_t used;
2000   size_t esize;
2001   struct EncryptedMessage *em;  /* encrypted message */
2002   struct EncryptedMessage *ph;  /* plaintext header */
2003   struct MessageEntry *me;
2004   unsigned int priority;
2005   struct GNUNET_TIME_Absolute deadline;
2006   struct GNUNET_TIME_Relative retry_time;
2007   GNUNET_HashCode iv;
2008
2009   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
2010     {
2011       GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
2012       n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
2013     }
2014   switch (n->status)
2015     {
2016     case PEER_STATE_DOWN:
2017       send_key (n);
2018 #if DEBUG_CORE
2019       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2020                   "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
2021                   GNUNET_i2s(&n->peer));
2022 #endif
2023       return;
2024     case PEER_STATE_KEY_SENT:
2025       if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
2026         n->retry_set_key_task
2027           = GNUNET_SCHEDULER_add_delayed (sched,
2028                                           n->set_key_retry_frequency,
2029                                           &set_key_retry_task, n);
2030 #if DEBUG_CORE
2031       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2032                   "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
2033                   GNUNET_i2s(&n->peer));
2034 #endif
2035       return;
2036     case PEER_STATE_KEY_RECEIVED:
2037       if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
2038         n->retry_set_key_task
2039           = GNUNET_SCHEDULER_add_delayed (sched,
2040                                           n->set_key_retry_frequency,
2041                                           &set_key_retry_task, n);
2042 #if DEBUG_CORE
2043       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2044                   "Not yet connected to `%4s', deferring processing of plaintext messages.\n",
2045                   GNUNET_i2s(&n->peer));
2046 #endif
2047       return;
2048     case PEER_STATE_KEY_CONFIRMED:
2049       /* ready to continue */
2050       break;
2051     }
2052   discard_expired_messages (n);
2053   if (n->messages == NULL)
2054     {
2055 #if DEBUG_CORE
2056       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2057                   "Plaintext message queue for `%4s' is empty.\n",
2058                   GNUNET_i2s(&n->peer));
2059 #endif
2060       return;                   /* no pending messages */
2061     }
2062   if (n->encrypted_head != NULL)
2063     {
2064 #if DEBUG_CORE
2065       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2066                   "Encrypted message queue for `%4s' is still full, delaying plaintext processing.\n",
2067                   GNUNET_i2s(&n->peer));
2068 #endif
2069       return;                   /* wait for messages already encrypted to be
2070                                    processed first! */
2071     }
2072   ph = (struct EncryptedMessage *) pbuf;
2073   deadline = GNUNET_TIME_UNIT_FOREVER_ABS;
2074   priority = 0;
2075   used = sizeof (struct EncryptedMessage);
2076   used += batch_message (n,
2077                          &pbuf[used],
2078                          GNUNET_CONSTANTS_MAX_ENCRYPTED_MESSAGE_SIZE,
2079                          &deadline, &retry_time, &priority);
2080   if (used == sizeof (struct EncryptedMessage))
2081     {
2082 #if DEBUG_CORE
2083       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2084                   "No messages selected for transmission to `%4s' at this time, will try again later.\n",
2085                   GNUNET_i2s(&n->peer));
2086 #endif
2087       /* no messages selected for sending, try again later... */
2088       n->retry_plaintext_task =
2089         GNUNET_SCHEDULER_add_delayed (sched,
2090                                       retry_time,
2091                                       &retry_plaintext_processing, n);
2092       return;
2093     }
2094 #if DEBUG_CORE_QUOTA
2095   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2096               "Sending %u b/s as new limit to peer `%4s'\n",
2097               (unsigned int) ntohl (n->bw_in.value__),
2098               GNUNET_i2s (&n->peer));
2099 #endif
2100   ph->iv_seed = htonl (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX));
2101   ph->sequence_number = htonl (++n->last_sequence_number_sent);
2102   ph->inbound_bw_limit = n->bw_in;
2103   ph->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
2104
2105   /* setup encryption message header */
2106   me = GNUNET_malloc (sizeof (struct MessageEntry) + used);
2107   me->deadline = deadline;
2108   me->priority = priority;
2109   me->size = used;
2110   em = (struct EncryptedMessage *) &me[1];
2111   em->header.size = htons (used);
2112   em->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE);
2113   em->iv_seed = ph->iv_seed;
2114   esize = used - ENCRYPTED_HEADER_SIZE;
2115   GNUNET_CRYPTO_hmac (&n->encrypt_key,
2116                       &ph->sequence_number,
2117                       esize - sizeof (GNUNET_HashCode),
2118                       &ph->hmac);
2119   GNUNET_CRYPTO_hash (&ph->iv_seed, sizeof (uint32_t), &iv);
2120 #if DEBUG_HANDSHAKE
2121   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2122               "Hashed %u bytes of plaintext (`%s') using IV `%d'\n",
2123               (unsigned int) (esize - sizeof (GNUNET_HashCode)),
2124               GNUNET_h2s (&ph->hmac),
2125               (int) ph->iv_seed);
2126 #endif
2127   /* encrypt */
2128 #if DEBUG_HANDSHAKE
2129   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2130               "Encrypting %u bytes of plaintext messages for `%4s' for transmission in %llums.\n",
2131               (unsigned int) esize,
2132               GNUNET_i2s(&n->peer),
2133               (unsigned long long) GNUNET_TIME_absolute_get_remaining (deadline).value);
2134 #endif
2135   GNUNET_assert (GNUNET_OK ==
2136                  do_encrypt (n,
2137                              &iv,
2138                              &ph->hmac,
2139                              &em->hmac, esize));
2140   /* append to transmission list */
2141   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2142                                      n->encrypted_tail,
2143                                      n->encrypted_tail,
2144                                      me);
2145   process_encrypted_neighbour_queue (n);
2146 }
2147
2148
2149 /**
2150  * Function that recalculates the bandwidth quota for the
2151  * given neighbour and transmits it to the transport service.
2152  *
2153  * @param cls neighbour for the quota update
2154  * @param tc context
2155  */
2156 static void
2157 neighbour_quota_update (void *cls,
2158                         const struct GNUNET_SCHEDULER_TaskContext *tc);
2159
2160
2161 /**
2162  * Schedule the task that will recalculate the bandwidth
2163  * quota for this peer (and possibly force a disconnect of
2164  * idle peers by calculating a bandwidth of zero).
2165  */
2166 static void
2167 schedule_quota_update (struct Neighbour *n)
2168 {
2169   GNUNET_assert (n->quota_update_task ==
2170                  GNUNET_SCHEDULER_NO_TASK);
2171   n->quota_update_task
2172     = GNUNET_SCHEDULER_add_delayed (sched,
2173                                     QUOTA_UPDATE_FREQUENCY,
2174                                     &neighbour_quota_update,
2175                                     n);
2176 }
2177
2178
2179 /**
2180  * Initialize a new 'struct Neighbour'.
2181  *
2182  * @param pid ID of the new neighbour
2183  * @return handle for the new neighbour
2184  */
2185 static struct Neighbour *
2186 create_neighbour (const struct GNUNET_PeerIdentity *pid)
2187 {
2188   struct Neighbour *n;
2189   struct GNUNET_TIME_Absolute now;
2190
2191 #if DEBUG_CORE
2192   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2193               "Creating neighbour entry for peer `%4s'\n",
2194               GNUNET_i2s (pid));
2195 #endif
2196   n = GNUNET_malloc (sizeof (struct Neighbour));
2197   n->next = neighbours;
2198   neighbours = n;
2199   neighbour_count++;
2200   GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), neighbour_count, GNUNET_NO);
2201   n->peer = *pid;
2202   GNUNET_CRYPTO_aes_create_session_key (&n->encrypt_key);
2203   now = GNUNET_TIME_absolute_get ();
2204   n->encrypt_key_created = now;
2205   n->last_activity = now;
2206   n->set_key_retry_frequency = INITIAL_SET_KEY_RETRY_FREQUENCY;
2207   n->bw_in = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
2208   n->bw_out = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
2209   n->bw_out_internal_limit = GNUNET_BANDWIDTH_value_init (UINT32_MAX);
2210   n->bw_out_external_limit = GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT;
2211   n->ping_challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
2212                                                 UINT32_MAX);
2213   neighbour_quota_update (n, NULL);
2214   consider_free_neighbour (n);
2215   return n;
2216 }
2217
2218
2219 /**
2220  * Handle CORE_SEND request.
2221  *
2222  * @param cls unused
2223  * @param client the client issuing the request
2224  * @param message the "struct SendMessage"
2225  */
2226 static void
2227 handle_client_send (void *cls,
2228                     struct GNUNET_SERVER_Client *client,
2229                     const struct GNUNET_MessageHeader *message)
2230 {
2231   const struct SendMessage *sm;
2232   struct Neighbour *n;
2233   struct MessageEntry *prev;
2234   struct MessageEntry *pos;
2235   struct MessageEntry *e;
2236   struct MessageEntry *min_prio_entry;
2237   struct MessageEntry *min_prio_prev;
2238   unsigned int min_prio;
2239   unsigned int queue_size;
2240   uint16_t msize;
2241
2242   msize = ntohs (message->size);
2243   if (msize <
2244       sizeof (struct SendMessage) + sizeof (struct GNUNET_MessageHeader))
2245     {
2246       GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "about to assert fail, msize is %d, should be less than %d\n", msize, sizeof (struct SendMessage) + sizeof (struct GNUNET_MessageHeader));
2247       GNUNET_break (0);
2248       if (client != NULL)
2249         GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2250       return;
2251     }
2252   sm = (const struct SendMessage *) message;
2253   msize -= sizeof (struct SendMessage);
2254   if (0 == memcmp (&sm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2255     {
2256       /* FIXME: should we not allow loopback-injection here? */
2257       GNUNET_break (0);
2258       if (client != NULL)
2259         GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2260       return;
2261     }
2262   n = find_neighbour (&sm->peer);
2263   if (n == NULL)
2264     n = create_neighbour (&sm->peer);
2265 #if DEBUG_CORE
2266   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2267               "Core received `%s' request, queueing %u bytes of plaintext data for transmission to `%4s'.\n",
2268               "SEND",
2269               (unsigned int) msize,
2270               GNUNET_i2s (&sm->peer));
2271 #endif
2272   /* bound queue size */
2273   discard_expired_messages (n);
2274   min_prio = UINT32_MAX;
2275   min_prio_entry = NULL;
2276   min_prio_prev = NULL;
2277   queue_size = 0;
2278   prev = NULL;
2279   pos = n->messages;
2280   while (pos != NULL)
2281     {
2282       if (pos->priority <= min_prio)
2283         {
2284           min_prio_entry = pos;
2285           min_prio_prev = prev;
2286           min_prio = pos->priority;
2287         }
2288       queue_size++;
2289       prev = pos;
2290       pos = pos->next;
2291     }
2292   if (queue_size >= MAX_PEER_QUEUE_SIZE)
2293     {
2294       /* queue full */
2295       if (ntohl(sm->priority) <= min_prio)
2296         {
2297           /* discard new entry */
2298 #if DEBUG_CORE
2299           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2300                       "Queue full (%u/%u), discarding new request (%u bytes of type %u)\n",
2301                       queue_size,
2302                       (unsigned int) MAX_PEER_QUEUE_SIZE,
2303                       (unsigned int) msize,
2304                       (unsigned int) ntohs (message->type));
2305 #endif
2306           if (client != NULL)
2307             GNUNET_SERVER_receive_done (client, GNUNET_OK);
2308           return;
2309         }
2310       GNUNET_assert (min_prio_entry != NULL);
2311       /* discard "min_prio_entry" */
2312 #if DEBUG_CORE
2313       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2314                   "Queue full, discarding existing older request\n");
2315 #endif
2316       if (min_prio_prev == NULL)
2317         n->messages = min_prio_entry->next;
2318       else
2319         min_prio_prev->next = min_prio_entry->next;
2320       GNUNET_free (min_prio_entry);
2321     }
2322
2323 #if DEBUG_CORE
2324   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2325               "Adding transmission request for `%4s' of size %u to queue\n",
2326               GNUNET_i2s (&sm->peer),
2327               (unsigned int) msize);
2328 #endif
2329   e = GNUNET_malloc (sizeof (struct MessageEntry) + msize);
2330   e->deadline = GNUNET_TIME_absolute_ntoh (sm->deadline);
2331   e->priority = ntohl (sm->priority);
2332   e->size = msize;
2333   memcpy (&e[1], &sm[1], msize);
2334
2335   /* insert, keep list sorted by deadline */
2336   prev = NULL;
2337   pos = n->messages;
2338   while ((pos != NULL) && (pos->deadline.value < e->deadline.value))
2339     {
2340       prev = pos;
2341       pos = pos->next;
2342     }
2343   if (prev == NULL)
2344     n->messages = e;
2345   else
2346     prev->next = e;
2347   e->next = pos;
2348
2349   /* consider scheduling now */
2350   process_plaintext_neighbour_queue (n);
2351   if (client != NULL)
2352     GNUNET_SERVER_receive_done (client, GNUNET_OK);
2353 }
2354
2355
2356 /**
2357  * Function called when the transport service is ready to
2358  * receive a message.  Only resets 'n->th' to NULL.
2359  *
2360  * @param cls neighbour to use message from
2361  * @param size number of bytes we can transmit
2362  * @param buf where to copy the message
2363  * @return number of bytes transmitted
2364  */
2365 static size_t
2366 notify_transport_connect_done (void *cls, size_t size, void *buf)
2367 {
2368   struct Neighbour *n = cls;
2369
2370   n->th = NULL;
2371   if (buf == NULL)
2372     {
2373       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2374                   _("Failed to connect to `%4s': transport failed to connect\n"),
2375                   GNUNET_i2s (&n->peer));
2376       return 0;
2377     }
2378   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2379               _("TRANSPORT connection to peer `%4s' is up, trying to establish CORE connection\n"),
2380               GNUNET_i2s (&n->peer));
2381   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2382     GNUNET_SCHEDULER_cancel (sched,
2383                              n->retry_set_key_task);
2384   n->retry_set_key_task = GNUNET_SCHEDULER_add_now (sched,
2385                                                     &set_key_retry_task,
2386                                                     n);
2387   return 0;
2388 }
2389
2390
2391 /**
2392  * Handle CORE_REQUEST_CONNECT request.
2393  *
2394  * @param cls unused
2395  * @param client the client issuing the request
2396  * @param message the "struct ConnectMessage"
2397  */
2398 static void
2399 handle_client_request_connect (void *cls,
2400                                struct GNUNET_SERVER_Client *client,
2401                                const struct GNUNET_MessageHeader *message)
2402 {
2403   const struct ConnectMessage *cm = (const struct ConnectMessage*) message;
2404   struct Neighbour *n;
2405   struct GNUNET_TIME_Relative timeout;
2406
2407   if (0 == memcmp (&cm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2408     {
2409       GNUNET_break (0);
2410       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2411       return;
2412     }
2413   GNUNET_SERVER_receive_done (client, GNUNET_OK);
2414   n = find_neighbour (&cm->peer);
2415   if (n == NULL)
2416     n = create_neighbour (&cm->peer);
2417   if ( (GNUNET_YES == n->is_connected) ||
2418        (n->th != NULL) )
2419     return; /* already connected, or at least trying */
2420   GNUNET_STATISTICS_update (stats, gettext_noop ("# connection requests received"), 1, GNUNET_NO);
2421 #if DEBUG_CORE
2422   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2423               "Core received `%s' request for `%4s', will try to establish connection\n",
2424               "REQUEST_CONNECT",
2425               GNUNET_i2s (&cm->peer));
2426 #endif
2427   timeout = GNUNET_TIME_relative_ntoh (cm->timeout);
2428   /* ask transport to connect to the peer */
2429   n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2430                                                   &cm->peer,
2431                                                   sizeof (struct GNUNET_MessageHeader), 0,
2432                                                   timeout,
2433                                                   &notify_transport_connect_done,
2434                                                   n);
2435   GNUNET_break (NULL != n->th);
2436 }
2437
2438
2439 /**
2440  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2441  * the neighbour's struct and retry send_key.  Or, if we did not get a
2442  * HELLO, just do nothing.
2443  *
2444  * @param cls the 'struct Neighbour' to retry sending the key for
2445  * @param peer the peer for which this is the HELLO
2446  * @param hello HELLO message of that peer
2447  */
2448 static void
2449 process_hello_retry_send_key (void *cls,
2450                               const struct GNUNET_PeerIdentity *peer,
2451                               const struct GNUNET_HELLO_Message *hello)
2452 {
2453   struct Neighbour *n = cls;
2454
2455   if (peer == NULL)
2456     {
2457 #if DEBUG_CORE
2458       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2459                   "Entered `%s' and `%s' is NULL!\n",
2460                   "process_hello_retry_send_key",
2461                   "peer");
2462 #endif
2463       n->pitr = NULL;
2464       if (n->public_key != NULL)
2465         {
2466           if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2467             {
2468               GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2469               n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2470             }
2471           GNUNET_STATISTICS_update (stats,
2472                                     gettext_noop ("# SET_KEY messages deferred (need public key)"),
2473                                     -1,
2474                                     GNUNET_NO);
2475           send_key (n);
2476         }
2477       else
2478         {
2479 #if DEBUG_CORE
2480           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2481                       "Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n",
2482                       GNUNET_i2s (&n->peer));
2483 #endif
2484           GNUNET_STATISTICS_update (stats,
2485                                     gettext_noop ("# Delayed connecting due to lack of public key"),
2486                                     1,
2487                                     GNUNET_NO);
2488           if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
2489             n->retry_set_key_task
2490               = GNUNET_SCHEDULER_add_delayed (sched,
2491                                               n->set_key_retry_frequency,
2492                                               &set_key_retry_task, n);
2493         }
2494       return;
2495     }
2496
2497 #if DEBUG_CORE
2498   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2499               "Entered `%s' for peer `%4s'\n",
2500               "process_hello_retry_send_key",
2501               GNUNET_i2s (peer));
2502 #endif
2503   if (n->public_key != NULL)
2504     {
2505       /* already have public key, why are we here? */
2506       GNUNET_break (0);
2507       return;
2508     }
2509
2510 #if DEBUG_CORE
2511   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2512               "Received new `%s' message for `%4s', initiating key exchange.\n",
2513               "HELLO",
2514               GNUNET_i2s (peer));
2515 #endif
2516   n->public_key =
2517     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2518   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2519     {
2520       GNUNET_STATISTICS_update (stats,
2521                                 gettext_noop ("# Error extracting public key from HELLO"),
2522                                 1,
2523                                 GNUNET_NO);
2524       GNUNET_free (n->public_key);
2525       n->public_key = NULL;
2526 #if DEBUG_CORE
2527   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2528               "GNUNET_HELLO_get_key returned awfully\n");
2529 #endif
2530       return;
2531     }
2532 }
2533
2534
2535 /**
2536  * Send our key (and encrypted PING) to the other peer.
2537  *
2538  * @param n the other peer
2539  */
2540 static void
2541 send_key (struct Neighbour *n)
2542 {
2543   struct MessageEntry *pos;
2544   struct SetKeyMessage *sm;
2545   struct MessageEntry *me;
2546   struct PingMessage pp;
2547   struct PingMessage *pm;
2548
2549   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2550     {
2551       GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2552       n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2553     }
2554   if (n->pitr != NULL)
2555     {
2556 #if DEBUG_CORE
2557       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2558                   "Key exchange in progress with `%4s'.\n",
2559                   GNUNET_i2s (&n->peer));
2560 #endif
2561       return; /* already in progress */
2562     }
2563   if (GNUNET_YES != n->is_connected)
2564     {
2565 #if DEBUG_CORE
2566       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2567                   "Not yet connected to peer `%4s'!\n",
2568                   GNUNET_i2s (&n->peer));
2569 #endif
2570       if (NULL == n->th)
2571         {
2572           GNUNET_STATISTICS_update (stats,
2573                                     gettext_noop ("# Asking transport to connect (for SET_KEY)"),
2574                                     1,
2575                                     GNUNET_NO);
2576           n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2577                                                           &n->peer,
2578                                                           sizeof (struct SetKeyMessage) + sizeof (struct PingMessage),
2579                                                           0,
2580                                                           GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2581                                                           &notify_encrypted_transmit_ready,
2582                                                           n);
2583         }
2584       return;
2585     }
2586 #if DEBUG_CORE
2587   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2588               "Asked to perform key exchange with `%4s'.\n",
2589               GNUNET_i2s (&n->peer));
2590 #endif
2591   if (n->public_key == NULL)
2592     {
2593       /* lookup n's public key, then try again */
2594 #if DEBUG_CORE
2595       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2596                   "Lacking public key for `%4s', trying to obtain one (send_key).\n",
2597                   GNUNET_i2s (&n->peer));
2598 #endif
2599       GNUNET_assert (n->pitr == NULL);
2600       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
2601                                          &n->peer,
2602                                          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20),
2603                                          &process_hello_retry_send_key, n);
2604       return;
2605     }
2606   pos = n->encrypted_head;
2607   while (pos != NULL)
2608     {
2609       if (GNUNET_YES == pos->is_setkey)
2610         {
2611           if (pos->sender_status == n->status)
2612             {
2613 #if DEBUG_CORE
2614               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2615                           "`%s' message for `%4s' queued already\n",
2616                           "SET_KEY",
2617                           GNUNET_i2s (&n->peer));
2618 #endif
2619               goto trigger_processing;
2620             }
2621           GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
2622                                        n->encrypted_tail,
2623                                        pos);
2624           GNUNET_free (pos);
2625 #if DEBUG_CORE
2626           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2627                       "Removing queued `%s' message for `%4s', will create a new one\n",
2628                       "SET_KEY",
2629                       GNUNET_i2s (&n->peer));
2630 #endif
2631           break;
2632         }
2633       pos = pos->next;
2634     }
2635
2636   /* update status */
2637   switch (n->status)
2638     {
2639     case PEER_STATE_DOWN:
2640       n->status = PEER_STATE_KEY_SENT;
2641       break;
2642     case PEER_STATE_KEY_SENT:
2643       break;
2644     case PEER_STATE_KEY_RECEIVED:
2645       break;
2646     case PEER_STATE_KEY_CONFIRMED:
2647       break;
2648     default:
2649       GNUNET_break (0);
2650       break;
2651     }
2652
2653
2654   /* first, set key message */
2655   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2656                       sizeof (struct SetKeyMessage) +
2657                       sizeof (struct PingMessage));
2658   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_SET_KEY_DELAY);
2659   me->priority = SET_KEY_PRIORITY;
2660   me->size = sizeof (struct SetKeyMessage) + sizeof (struct PingMessage);
2661   me->is_setkey = GNUNET_YES;
2662   me->got_slack = GNUNET_YES; /* do not defer this one! */
2663   me->sender_status = n->status;
2664   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2665                                      n->encrypted_tail,
2666                                      n->encrypted_tail,
2667                                      me);
2668   sm = (struct SetKeyMessage *) &me[1];
2669   sm->header.size = htons (sizeof (struct SetKeyMessage));
2670   sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SET_KEY);
2671   sm->sender_status = htonl ((int32_t) ((n->status == PEER_STATE_DOWN) ?
2672                                         PEER_STATE_KEY_SENT : n->status));
2673   sm->purpose.size =
2674     htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
2675            sizeof (struct GNUNET_TIME_AbsoluteNBO) +
2676            sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
2677            sizeof (struct GNUNET_PeerIdentity));
2678   sm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SET_KEY);
2679   sm->creation_time = GNUNET_TIME_absolute_hton (n->encrypt_key_created);
2680   sm->target = n->peer;
2681   GNUNET_assert (GNUNET_OK ==
2682                  GNUNET_CRYPTO_rsa_encrypt (&n->encrypt_key,
2683                                             sizeof (struct
2684                                                     GNUNET_CRYPTO_AesSessionKey),
2685                                             n->public_key,
2686                                             &sm->encrypted_key));
2687   GNUNET_assert (GNUNET_OK ==
2688                  GNUNET_CRYPTO_rsa_sign (my_private_key, &sm->purpose,
2689                                          &sm->signature));
2690   pm = (struct PingMessage *) &sm[1];
2691   pm->header.size = htons (sizeof (struct PingMessage));
2692   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
2693   pp.challenge = htonl (n->ping_challenge);
2694   pp.target = n->peer;
2695 #if DEBUG_HANDSHAKE
2696   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2697               "Encrypting `%s' and `%s' messages with challenge %u for `%4s' using key %u.\n",
2698               "SET_KEY", "PING",
2699               (unsigned int) n->ping_challenge,
2700               GNUNET_i2s (&n->peer),
2701               (unsigned int) n->encrypt_key.crc32);
2702 #endif
2703   do_encrypt (n,
2704               &n->peer.hashPubKey,
2705               &pp.challenge,
2706               &pm->challenge,
2707               sizeof (struct PingMessage) -
2708               sizeof (struct GNUNET_MessageHeader));
2709   GNUNET_STATISTICS_update (stats,
2710                             gettext_noop ("# SET_KEY and PING messages created"),
2711                             1,
2712                             GNUNET_NO);
2713 #if DEBUG_CORE
2714   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2715               "Have %llu ms left for `%s' transmission.\n",
2716               (unsigned long long) GNUNET_TIME_absolute_get_remaining (me->deadline).value,
2717               "SET_KEY");
2718 #endif
2719  trigger_processing:
2720   /* trigger queue processing */
2721   process_encrypted_neighbour_queue (n);
2722   if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
2723        (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
2724     n->retry_set_key_task
2725       = GNUNET_SCHEDULER_add_delayed (sched,
2726                                       n->set_key_retry_frequency,
2727                                       &set_key_retry_task, n);
2728 }
2729
2730
2731 /**
2732  * We received a SET_KEY message.  Validate and update
2733  * our key material and status.
2734  *
2735  * @param n the neighbour from which we received message m
2736  * @param m the set key message we received
2737  */
2738 static void
2739 handle_set_key (struct Neighbour *n,
2740                 const struct SetKeyMessage *m);
2741
2742
2743 /**
2744  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2745  * the neighbour's struct and retry handling the set_key message.  Or,
2746  * if we did not get a HELLO, just free the set key message.
2747  *
2748  * @param cls pointer to the set key message
2749  * @param peer the peer for which this is the HELLO
2750  * @param hello HELLO message of that peer
2751  */
2752 static void
2753 process_hello_retry_handle_set_key (void *cls,
2754                                     const struct GNUNET_PeerIdentity *peer,
2755                                     const struct GNUNET_HELLO_Message *hello)
2756 {
2757   struct Neighbour *n = cls;
2758   struct SetKeyMessage *sm = n->skm;
2759
2760   if (peer == NULL)
2761     {
2762       n->skm = NULL;
2763       n->pitr = NULL;
2764       if (n->public_key != NULL)
2765         {
2766 #if DEBUG_CORE
2767           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2768                       "Received `%s' for `%4s', continuing processing of `%s' message.\n",
2769                       "HELLO",
2770                       GNUNET_i2s (&n->peer),
2771                       "SET_KEY");
2772 #endif
2773           handle_set_key (n, sm);
2774         }
2775       else
2776         {
2777           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2778                       _("Ignoring `%s' message due to lack of public key for peer `%4s' (failed to obtain one).\n"),
2779                       "SET_KEY",
2780                       GNUNET_i2s (&n->peer));
2781         }
2782       GNUNET_free (sm);
2783       return;
2784     }
2785   if (n->public_key != NULL)
2786     return;                     /* multiple HELLOs match!? */
2787   n->public_key =
2788     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2789   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2790     {
2791       GNUNET_break_op (0);
2792       GNUNET_free (n->public_key);
2793       n->public_key = NULL;
2794     }
2795 }
2796
2797
2798 /**
2799  * We received a PING message.  Validate and transmit
2800  * PONG.
2801  *
2802  * @param n sender of the PING
2803  * @param m the encrypted PING message itself
2804  */
2805 static void
2806 handle_ping (struct Neighbour *n, const struct PingMessage *m)
2807 {
2808   struct PingMessage t;
2809   struct PongMessage tx;
2810   struct PongMessage *tp;
2811   struct MessageEntry *me;
2812
2813 #if DEBUG_CORE
2814   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2815               "Core service receives `%s' request from `%4s'.\n",
2816               "PING", GNUNET_i2s (&n->peer));
2817 #endif
2818   if (GNUNET_OK !=
2819       do_decrypt (n,
2820                   &my_identity.hashPubKey,
2821                   &m->challenge,
2822                   &t.challenge,
2823                   sizeof (struct PingMessage) -
2824                   sizeof (struct GNUNET_MessageHeader)))
2825     return;
2826 #if DEBUG_HANDSHAKE
2827   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2828               "Decrypted `%s' to `%4s' with challenge %u decrypted using key %u\n",
2829               "PING",
2830               GNUNET_i2s (&t.target),
2831               (unsigned int) ntohl (t.challenge),
2832               (unsigned int) n->decrypt_key.crc32);
2833 #endif
2834   GNUNET_STATISTICS_update (stats,
2835                             gettext_noop ("# PING messages decrypted"),
2836                             1,
2837                             GNUNET_NO);
2838   if (0 != memcmp (&t.target,
2839                    &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2840     {
2841       GNUNET_break_op (0);
2842       return;
2843     }
2844   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2845                       sizeof (struct PongMessage));
2846   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2847                                      n->encrypted_tail,
2848                                      n->encrypted_tail,
2849                                      me);
2850   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PONG_DELAY);
2851   me->priority = PONG_PRIORITY;
2852   me->size = sizeof (struct PongMessage);
2853   tx.reserved = htonl (0);
2854   tx.inbound_bw_limit = n->bw_in;
2855   tx.challenge = t.challenge;
2856   tx.target = t.target;
2857   tp = (struct PongMessage *) &me[1];
2858   tp->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PONG);
2859   tp->header.size = htons (sizeof (struct PongMessage));
2860   do_encrypt (n,
2861               &my_identity.hashPubKey,
2862               &tx.challenge,
2863               &tp->challenge,
2864               sizeof (struct PongMessage) -
2865               sizeof (struct GNUNET_MessageHeader));
2866   GNUNET_STATISTICS_update (stats,
2867                             gettext_noop ("# PONG messages created"),
2868                             1,
2869                             GNUNET_NO);
2870 #if DEBUG_HANDSHAKE
2871   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2872               "Encrypting `%s' with challenge %u using key %u\n",
2873               "PONG",
2874               (unsigned int) ntohl (t.challenge),
2875               (unsigned int) n->encrypt_key.crc32);
2876 #endif
2877   /* trigger queue processing */
2878   process_encrypted_neighbour_queue (n);
2879 }
2880
2881
2882 /**
2883  * We received a PONG message.  Validate and update our status.
2884  *
2885  * @param n sender of the PONG
2886  * @param m the encrypted PONG message itself
2887  */
2888 static void
2889 handle_pong (struct Neighbour *n,
2890              const struct PongMessage *m)
2891 {
2892   struct PongMessage t;
2893   struct ConnectNotifyMessage cnm;
2894
2895 #if DEBUG_CORE
2896   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2897               "Core service receives `%s' response from `%4s'.\n",
2898               "PONG", GNUNET_i2s (&n->peer));
2899 #endif
2900   /* mark as garbage, just to be sure */
2901   memset (&t, 255, sizeof (t));
2902   if (GNUNET_OK !=
2903       do_decrypt (n,
2904                   &n->peer.hashPubKey,
2905                   &m->challenge,
2906                   &t.challenge,
2907                   sizeof (struct PongMessage) -
2908                   sizeof (struct GNUNET_MessageHeader)))
2909     {
2910       GNUNET_break_op (0);
2911       return;
2912     }
2913   GNUNET_STATISTICS_update (stats,
2914                             gettext_noop ("# PONG messages decrypted"),
2915                             1,
2916                             GNUNET_NO);
2917   if (0 != ntohl (t.reserved))
2918     {
2919       GNUNET_break_op (0);
2920       return;
2921     }
2922 #if DEBUG_HANDSHAKE
2923   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2924               "Decrypted `%s' from `%4s' with challenge %u using key %u\n",
2925               "PONG",
2926               GNUNET_i2s (&t.target),
2927               (unsigned int) ntohl (t.challenge),
2928               (unsigned int) n->decrypt_key.crc32);
2929 #endif
2930   if ((0 != memcmp (&t.target,
2931                     &n->peer,
2932                     sizeof (struct GNUNET_PeerIdentity))) ||
2933       (n->ping_challenge != ntohl (t.challenge)))
2934     {
2935       /* PONG malformed */
2936 #if DEBUG_CORE
2937       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2938                   "Received malformed `%s' wanted sender `%4s' with challenge %u\n",
2939                   "PONG",
2940                   GNUNET_i2s (&n->peer),
2941                   (unsigned int) n->ping_challenge);
2942       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2943                   "Received malformed `%s' received from `%4s' with challenge %u\n",
2944                   "PONG", GNUNET_i2s (&t.target),
2945                   (unsigned int) ntohl (t.challenge));
2946 #endif
2947       GNUNET_break_op (0);
2948       return;
2949     }
2950   switch (n->status)
2951     {
2952     case PEER_STATE_DOWN:
2953       GNUNET_break (0);         /* should be impossible */
2954       return;
2955     case PEER_STATE_KEY_SENT:
2956       GNUNET_break (0);         /* should be impossible, how did we decrypt? */
2957       return;
2958     case PEER_STATE_KEY_RECEIVED:
2959       GNUNET_STATISTICS_update (stats,
2960                                 gettext_noop ("# Session keys confirmed via PONG"),
2961                                 1,
2962                                 GNUNET_NO);
2963       n->status = PEER_STATE_KEY_CONFIRMED;
2964       if (n->bw_out_external_limit.value__ != t.inbound_bw_limit.value__)
2965         {
2966           n->bw_out_external_limit = t.inbound_bw_limit;
2967           n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
2968                                                   n->bw_out_internal_limit);
2969           GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
2970                                                  n->bw_out);
2971           GNUNET_TRANSPORT_set_quota (transport,
2972                                       &n->peer,
2973                                       n->bw_in,
2974                                       n->bw_out,
2975                                       GNUNET_TIME_UNIT_FOREVER_REL,
2976                                       NULL, NULL);
2977         }
2978 #if DEBUG_CORE
2979       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2980                   "Confirmed key via `%s' message for peer `%4s'\n",
2981                   "PONG", GNUNET_i2s (&n->peer));
2982 #endif
2983       if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2984         {
2985           GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2986           n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2987         }
2988       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
2989       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
2990       cnm.distance = htonl (n->last_distance);
2991       cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
2992       cnm.peer = n->peer;
2993       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_CONNECT);
2994       process_encrypted_neighbour_queue (n);
2995       /* fall-through! */
2996     case PEER_STATE_KEY_CONFIRMED:
2997       n->last_activity = GNUNET_TIME_absolute_get ();
2998       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
2999         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3000       n->keep_alive_task
3001         = GNUNET_SCHEDULER_add_delayed (sched,
3002                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3003                                         &send_keep_alive,
3004                                         n);
3005       handle_peer_status_change (n);
3006       break;
3007     default:
3008       GNUNET_break (0);
3009       break;
3010     }
3011 }
3012
3013
3014 /**
3015  * We received a SET_KEY message.  Validate and update
3016  * our key material and status.
3017  *
3018  * @param n the neighbour from which we received message m
3019  * @param m the set key message we received
3020  */
3021 static void
3022 handle_set_key (struct Neighbour *n, const struct SetKeyMessage *m)
3023 {
3024   struct SetKeyMessage *m_cpy;
3025   struct GNUNET_TIME_Absolute t;
3026   struct GNUNET_CRYPTO_AesSessionKey k;
3027   struct PingMessage *ping;
3028   struct PongMessage *pong;
3029   enum PeerStateMachine sender_status;
3030
3031 #if DEBUG_CORE
3032   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3033               "Core service receives `%s' request from `%4s'.\n",
3034               "SET_KEY", GNUNET_i2s (&n->peer));
3035 #endif
3036   if (n->public_key == NULL)
3037     {
3038       if (n->pitr != NULL)
3039         {
3040 #if DEBUG_CORE
3041           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3042                       "Ignoring `%s' message due to lack of public key for peer (still trying to obtain one).\n",
3043                       "SET_KEY");
3044 #endif
3045           return;
3046         }
3047 #if DEBUG_CORE
3048       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3049                   "Lacking public key for peer, trying to obtain one (handle_set_key).\n");
3050 #endif
3051       m_cpy = GNUNET_malloc (sizeof (struct SetKeyMessage));
3052       memcpy (m_cpy, m, sizeof (struct SetKeyMessage));
3053       /* lookup n's public key, then try again */
3054       GNUNET_assert (n->skm == NULL);
3055       n->skm = m_cpy;
3056       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
3057                                          &n->peer,
3058                                          GNUNET_TIME_UNIT_MINUTES,
3059                                          &process_hello_retry_handle_set_key, n);
3060       GNUNET_STATISTICS_update (stats,
3061                                 gettext_noop ("# SET_KEY messages deferred (need public key)"),
3062                                 1,
3063                                 GNUNET_NO);
3064       return;
3065     }
3066   if (0 != memcmp (&m->target,
3067                    &my_identity,
3068                    sizeof (struct GNUNET_PeerIdentity)))
3069     {
3070       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3071                   _("Received `%s' message that was for `%s', not for me.  Ignoring.\n"),
3072                   "SET_KEY",
3073                   GNUNET_i2s (&m->target));
3074       return;
3075     }
3076   if ((ntohl (m->purpose.size) !=
3077        sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
3078        sizeof (struct GNUNET_TIME_AbsoluteNBO) +
3079        sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
3080        sizeof (struct GNUNET_PeerIdentity)) ||
3081       (GNUNET_OK !=
3082        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_SET_KEY,
3083                                  &m->purpose, &m->signature, n->public_key)))
3084     {
3085       /* invalid signature */
3086       GNUNET_break_op (0);
3087       return;
3088     }
3089   t = GNUNET_TIME_absolute_ntoh (m->creation_time);
3090   if (((n->status == PEER_STATE_KEY_RECEIVED) ||
3091        (n->status == PEER_STATE_KEY_CONFIRMED)) &&
3092       (t.value < n->decrypt_key_created.value))
3093     {
3094       /* this could rarely happen due to massive re-ordering of
3095          messages on the network level, but is most likely either
3096          a bug or some adversary messing with us.  Report. */
3097       GNUNET_break_op (0);
3098       return;
3099     }
3100 #if DEBUG_CORE
3101   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3102               "Decrypting key material.\n");
3103 #endif
3104   if ((GNUNET_CRYPTO_rsa_decrypt (my_private_key,
3105                                   &m->encrypted_key,
3106                                   &k,
3107                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey))
3108        != sizeof (struct GNUNET_CRYPTO_AesSessionKey)) ||
3109       (GNUNET_OK != GNUNET_CRYPTO_aes_check_session_key (&k)))
3110     {
3111       /* failed to decrypt !? */
3112       GNUNET_break_op (0);
3113       return;
3114     }
3115   GNUNET_STATISTICS_update (stats,
3116                             gettext_noop ("# SET_KEY messages decrypted"),
3117                             1,
3118                             GNUNET_NO);
3119   n->decrypt_key = k;
3120   if (n->decrypt_key_created.value != t.value)
3121     {
3122       /* fresh key, reset sequence numbers */
3123       n->last_sequence_number_received = 0;
3124       n->last_packets_bitmap = 0;
3125       n->decrypt_key_created = t;
3126     }
3127   sender_status = (enum PeerStateMachine) ntohl (m->sender_status);
3128   switch (n->status)
3129     {
3130     case PEER_STATE_DOWN:
3131       n->status = PEER_STATE_KEY_RECEIVED;
3132 #if DEBUG_CORE
3133       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3134                   "Responding to `%s' with my own key.\n", "SET_KEY");
3135 #endif
3136       send_key (n);
3137       break;
3138     case PEER_STATE_KEY_SENT:
3139     case PEER_STATE_KEY_RECEIVED:
3140       n->status = PEER_STATE_KEY_RECEIVED;
3141       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3142           (sender_status != PEER_STATE_KEY_CONFIRMED))
3143         {
3144 #if DEBUG_CORE
3145           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3146                       "Responding to `%s' with my own key (other peer has status %u).\n",
3147                       "SET_KEY",
3148                       (unsigned int) sender_status);
3149 #endif
3150           send_key (n);
3151         }
3152       break;
3153     case PEER_STATE_KEY_CONFIRMED:
3154       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3155           (sender_status != PEER_STATE_KEY_CONFIRMED))
3156         {
3157 #if DEBUG_CORE
3158           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3159                       "Responding to `%s' with my own key (other peer has status %u), I was already fully up.\n",
3160                       "SET_KEY",
3161                       (unsigned int) sender_status);
3162 #endif
3163           send_key (n);
3164         }
3165       break;
3166     default:
3167       GNUNET_break (0);
3168       break;
3169     }
3170   if (n->pending_ping != NULL)
3171     {
3172       ping = n->pending_ping;
3173       n->pending_ping = NULL;
3174       handle_ping (n, ping);
3175       GNUNET_free (ping);
3176     }
3177   if (n->pending_pong != NULL)
3178     {
3179       pong = n->pending_pong;
3180       n->pending_pong = NULL;
3181       handle_pong (n, pong);
3182       GNUNET_free (pong);
3183     }
3184 }
3185
3186
3187 /**
3188  * Send a P2P message to a client.
3189  *
3190  * @param sender who sent us the message?
3191  * @param client who should we give the message to?
3192  * @param m contains the message to transmit
3193  * @param msize number of bytes in buf to transmit
3194  */
3195 static void
3196 send_p2p_message_to_client (struct Neighbour *sender,
3197                             struct Client *client,
3198                             const void *m, size_t msize)
3199 {
3200   char buf[msize + sizeof (struct NotifyTrafficMessage)];
3201   struct NotifyTrafficMessage *ntm;
3202
3203 #if DEBUG_CORE
3204   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3205               "Core service passes message from `%4s' of type %u to client.\n",
3206               GNUNET_i2s(&sender->peer),
3207               (unsigned int) ntohs (((const struct GNUNET_MessageHeader *) m)->type));
3208 #endif
3209   ntm = (struct NotifyTrafficMessage *) buf;
3210   ntm->header.size = htons (msize + sizeof (struct NotifyTrafficMessage));
3211   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND);
3212   ntm->distance = htonl (sender->last_distance);
3213   ntm->latency = GNUNET_TIME_relative_hton (sender->last_latency);
3214   ntm->peer = sender->peer;
3215   memcpy (&ntm[1], m, msize);
3216   send_to_client (client, &ntm->header, GNUNET_YES);
3217 }
3218
3219
3220 /**
3221  * Deliver P2P message to interested clients.
3222  *
3223  * @param cls always NULL
3224  * @param client who sent us the message (struct Neighbour)
3225  * @param m the message
3226  */
3227 static void
3228 deliver_message (void *cls,
3229                  void *client,
3230                  const struct GNUNET_MessageHeader *m)
3231 {
3232   struct Neighbour *sender = client;
3233   size_t msize = ntohs (m->size);
3234   char buf[256];
3235   struct Client *cpos;
3236   uint16_t type;
3237   unsigned int tpos;
3238   int deliver_full;
3239   int dropped;
3240
3241   type = ntohs (m->type);
3242 #if DEBUG_CORE
3243   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3244               "Received encapsulated message of type %u and size %u from `%4s'\n",
3245               (unsigned int) type,
3246               ntohs (m->size),
3247               GNUNET_i2s (&sender->peer));
3248 #endif
3249   GNUNET_snprintf (buf,
3250                    sizeof(buf),
3251                    gettext_noop ("# bytes of messages of type %u received"),
3252                    (unsigned int) type);
3253   GNUNET_STATISTICS_set (stats,
3254                          buf,
3255                          msize,
3256                          GNUNET_NO);
3257   dropped = GNUNET_YES;
3258   cpos = clients;
3259   while (cpos != NULL)
3260     {
3261       deliver_full = GNUNET_NO;
3262       if (0 != (cpos->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
3263         deliver_full = GNUNET_YES;
3264       else
3265         {
3266           for (tpos = 0; tpos < cpos->tcnt; tpos++)
3267             {
3268               if (type != cpos->types[tpos])
3269                 continue;
3270               deliver_full = GNUNET_YES;
3271               break;
3272             }
3273         }
3274       if (GNUNET_YES == deliver_full)
3275         {
3276           send_p2p_message_to_client (sender, cpos, m, msize);
3277           dropped = GNUNET_NO;
3278         }
3279       else if (cpos->options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)
3280         {
3281           send_p2p_message_to_client (sender, cpos, m,
3282                                       sizeof (struct GNUNET_MessageHeader));
3283         }
3284       cpos = cpos->next;
3285     }
3286   if (dropped == GNUNET_YES)
3287     {
3288 #if DEBUG_CORE
3289       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3290                   "Message of type %u from `%4s' not delivered to any client.\n",
3291                   (unsigned int) type,
3292                   GNUNET_i2s (&sender->peer));
3293 #endif
3294       GNUNET_STATISTICS_update (stats,
3295                                 gettext_noop ("# messages not delivered to any client"),
3296                                 1, GNUNET_NO);
3297     }
3298 }
3299
3300
3301 /**
3302  * We received an encrypted message.  Decrypt, validate and
3303  * pass on to the appropriate clients.
3304  */
3305 static void
3306 handle_encrypted_message (struct Neighbour *n,
3307                           const struct EncryptedMessage *m)
3308 {
3309   size_t size = ntohs (m->header.size);
3310   char buf[size];
3311   struct EncryptedMessage *pt;  /* plaintext */
3312   GNUNET_HashCode ph;
3313   uint32_t snum;
3314   struct GNUNET_TIME_Absolute t;
3315   GNUNET_HashCode iv;
3316
3317 #if DEBUG_CORE
3318   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3319               "Core service receives `%s' request from `%4s'.\n",
3320               "ENCRYPTED_MESSAGE", GNUNET_i2s (&n->peer));
3321 #endif
3322   GNUNET_CRYPTO_hash (&m->iv_seed, sizeof (uint32_t), &iv);
3323   /* decrypt */
3324   if (GNUNET_OK !=
3325       do_decrypt (n,
3326                   &iv,
3327                   &m->hmac,
3328                   &buf[ENCRYPTED_HEADER_SIZE],
3329                   size - ENCRYPTED_HEADER_SIZE))
3330     return;
3331   pt = (struct EncryptedMessage *) buf;
3332   /* validate hash */
3333   GNUNET_CRYPTO_hmac (&n->decrypt_key,
3334                       &pt->sequence_number,
3335                       size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode), &ph);
3336 #if DEBUG_HANDSHAKE
3337   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3338               "V-Hashed %u bytes of plaintext (`%s') using IV `%d'\n",
3339               (unsigned int) (size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode)),
3340               GNUNET_h2s (&ph),
3341               (int) m->iv_seed);
3342 #endif
3343   if (0 != memcmp (&ph,
3344                    &pt->hmac,
3345                    sizeof (GNUNET_HashCode)))
3346     {
3347       /* checksum failed */
3348       GNUNET_break_op (0);
3349       return;
3350     }
3351
3352   /* validate sequence number */
3353   snum = ntohl (pt->sequence_number);
3354   if (n->last_sequence_number_received == snum)
3355     {
3356       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3357                   "Received duplicate message, ignoring.\n");
3358       /* duplicate, ignore */
3359       GNUNET_STATISTICS_set (stats,
3360                              gettext_noop ("# bytes dropped (duplicates)"),
3361                              size,
3362                              GNUNET_NO);
3363       return;
3364     }
3365   if ((n->last_sequence_number_received > snum) &&
3366       (n->last_sequence_number_received - snum > 32))
3367     {
3368       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3369                   "Received ancient out of sequence message, ignoring.\n");
3370       /* ancient out of sequence, ignore */
3371       GNUNET_STATISTICS_set (stats,
3372                              gettext_noop ("# bytes dropped (out of sequence)"),
3373                              size,
3374                              GNUNET_NO);
3375       return;
3376     }
3377   if (n->last_sequence_number_received > snum)
3378     {
3379       unsigned int rotbit =
3380         1 << (n->last_sequence_number_received - snum - 1);
3381       if ((n->last_packets_bitmap & rotbit) != 0)
3382         {
3383           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3384                       "Received duplicate message, ignoring.\n");
3385           GNUNET_STATISTICS_set (stats,
3386                                  gettext_noop ("# bytes dropped (duplicates)"),
3387                                  size,
3388                                  GNUNET_NO);
3389           /* duplicate, ignore */
3390           return;
3391         }
3392       n->last_packets_bitmap |= rotbit;
3393     }
3394   if (n->last_sequence_number_received < snum)
3395     {
3396       n->last_packets_bitmap <<= (snum - n->last_sequence_number_received);
3397       n->last_sequence_number_received = snum;
3398     }
3399
3400   /* check timestamp */
3401   t = GNUNET_TIME_absolute_ntoh (pt->timestamp);
3402   if (GNUNET_TIME_absolute_get_duration (t).value > MAX_MESSAGE_AGE.value)
3403     {
3404       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3405                   _
3406                   ("Message received far too old (%llu ms). Content ignored.\n"),
3407                   GNUNET_TIME_absolute_get_duration (t).value);
3408       GNUNET_STATISTICS_set (stats,
3409                              gettext_noop ("# bytes dropped (ancient message)"),
3410                              size,
3411                              GNUNET_NO);
3412       return;
3413     }
3414
3415   /* process decrypted message(s) */
3416   if (n->bw_out_external_limit.value__ != pt->inbound_bw_limit.value__)
3417     {
3418 #if DEBUG_CORE_SET_QUOTA
3419       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3420                   "Received %u b/s as new inbound limit for peer `%4s'\n",
3421                   (unsigned int) ntohl (pt->inbound_bw_limit.value__),
3422                   GNUNET_i2s (&n->peer));
3423 #endif
3424       n->bw_out_external_limit = pt->inbound_bw_limit;
3425       n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
3426                                               n->bw_out_internal_limit);
3427       GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
3428                                              n->bw_out);
3429       GNUNET_TRANSPORT_set_quota (transport,
3430                                   &n->peer,
3431                                   n->bw_in,
3432                                   n->bw_out,
3433                                   GNUNET_TIME_UNIT_FOREVER_REL,
3434                                   NULL, NULL);
3435     }
3436   n->last_activity = GNUNET_TIME_absolute_get ();
3437   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3438     GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3439   n->keep_alive_task
3440     = GNUNET_SCHEDULER_add_delayed (sched,
3441                                     GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3442                                     &send_keep_alive,
3443                                     n);
3444   GNUNET_STATISTICS_set (stats,
3445                          gettext_noop ("# bytes of payload decrypted"),
3446                          size - sizeof (struct EncryptedMessage),
3447                          GNUNET_NO);
3448   handle_peer_status_change (n);
3449   if (GNUNET_OK != GNUNET_SERVER_mst_receive (mst,
3450                                               n,
3451                                               &buf[sizeof (struct EncryptedMessage)],
3452                                               size - sizeof (struct EncryptedMessage),
3453                                               GNUNET_YES, GNUNET_NO))
3454     GNUNET_break_op (0);
3455 }
3456
3457
3458 /**
3459  * Function called by the transport for each received message.
3460  *
3461  * @param cls closure
3462  * @param peer (claimed) identity of the other peer
3463  * @param message the message
3464  * @param latency estimated latency for communicating with the
3465  *             given peer (round-trip)
3466  * @param distance in overlay hops, as given by transport plugin
3467  */
3468 static void
3469 handle_transport_receive (void *cls,
3470                           const struct GNUNET_PeerIdentity *peer,
3471                           const struct GNUNET_MessageHeader *message,
3472                           struct GNUNET_TIME_Relative latency,
3473                           unsigned int distance)
3474 {
3475   struct Neighbour *n;
3476   struct GNUNET_TIME_Absolute now;
3477   int up;
3478   uint16_t type;
3479   uint16_t size;
3480   int changed;
3481
3482 #if DEBUG_CORE
3483   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3484               "Received message of type %u from `%4s', demultiplexing.\n",
3485               (unsigned int) ntohs (message->type),
3486               GNUNET_i2s (peer));
3487 #endif
3488   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3489     {
3490       GNUNET_break (0);
3491       return;
3492     }
3493   n = find_neighbour (peer);
3494   if (n == NULL)
3495     n = create_neighbour (peer);
3496   changed = (latency.value != n->last_latency.value) || (distance != n->last_distance);
3497   n->last_latency = latency;
3498   n->last_distance = distance;
3499   up = (n->status == PEER_STATE_KEY_CONFIRMED);
3500   type = ntohs (message->type);
3501   size = ntohs (message->size);
3502   switch (type)
3503     {
3504     case GNUNET_MESSAGE_TYPE_CORE_SET_KEY:
3505       if (size != sizeof (struct SetKeyMessage))
3506         {
3507           GNUNET_break_op (0);
3508           return;
3509         }
3510       GNUNET_STATISTICS_update (stats, gettext_noop ("# session keys received"), 1, GNUNET_NO);
3511       handle_set_key (n, (const struct SetKeyMessage *) message);
3512       break;
3513     case GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE:
3514       if (size < sizeof (struct EncryptedMessage) +
3515           sizeof (struct GNUNET_MessageHeader))
3516         {
3517           GNUNET_break_op (0);
3518           return;
3519         }
3520       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3521           (n->status != PEER_STATE_KEY_CONFIRMED))
3522         {
3523           GNUNET_break_op (0);
3524           return;
3525         }
3526       handle_encrypted_message (n, (const struct EncryptedMessage *) message);
3527       break;
3528     case GNUNET_MESSAGE_TYPE_CORE_PING:
3529       if (size != sizeof (struct PingMessage))
3530         {
3531           GNUNET_break_op (0);
3532           return;
3533         }
3534       GNUNET_STATISTICS_update (stats, gettext_noop ("# PING messages received"), 1, GNUNET_NO);
3535       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3536           (n->status != PEER_STATE_KEY_CONFIRMED))
3537         {
3538 #if DEBUG_CORE
3539           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3540                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3541                       "PING", GNUNET_i2s (&n->peer));
3542 #endif
3543           GNUNET_free_non_null (n->pending_ping);
3544           n->pending_ping = GNUNET_malloc (sizeof (struct PingMessage));
3545           memcpy (n->pending_ping, message, sizeof (struct PingMessage));
3546           return;
3547         }
3548       handle_ping (n, (const struct PingMessage *) message);
3549       break;
3550     case GNUNET_MESSAGE_TYPE_CORE_PONG:
3551       if (size != sizeof (struct PongMessage))
3552         {
3553           GNUNET_break_op (0);
3554           return;
3555         }
3556       GNUNET_STATISTICS_update (stats, gettext_noop ("# PONG messages received"), 1, GNUNET_NO);
3557       if ( (n->status != PEER_STATE_KEY_RECEIVED) &&
3558            (n->status != PEER_STATE_KEY_CONFIRMED) )
3559         {
3560 #if DEBUG_CORE
3561           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3562                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3563                       "PONG", GNUNET_i2s (&n->peer));
3564 #endif
3565           GNUNET_free_non_null (n->pending_pong);
3566           n->pending_pong = GNUNET_malloc (sizeof (struct PongMessage));
3567           memcpy (n->pending_pong, message, sizeof (struct PongMessage));
3568           return;
3569         }
3570       handle_pong (n, (const struct PongMessage *) message);
3571       break;
3572     default:
3573       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3574                   _("Unsupported message of type %u received.\n"),
3575                   (unsigned int) type);
3576       return;
3577     }
3578   if (n->status == PEER_STATE_KEY_CONFIRMED)
3579     {
3580       now = GNUNET_TIME_absolute_get ();
3581       n->last_activity = now;
3582       changed = GNUNET_YES;
3583       if (!up)
3584         {
3585           GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), 1, GNUNET_NO);
3586           n->time_established = now;
3587         }
3588       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3589         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3590       n->keep_alive_task
3591         = GNUNET_SCHEDULER_add_delayed (sched,
3592                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3593                                         &send_keep_alive,
3594                                         n);
3595     }
3596   if (changed)
3597     handle_peer_status_change (n);
3598 }
3599
3600
3601 /**
3602  * Function that recalculates the bandwidth quota for the
3603  * given neighbour and transmits it to the transport service.
3604  *
3605  * @param cls neighbour for the quota update
3606  * @param tc context
3607  */
3608 static void
3609 neighbour_quota_update (void *cls,
3610                         const struct GNUNET_SCHEDULER_TaskContext *tc)
3611 {
3612   struct Neighbour *n = cls;
3613   struct GNUNET_BANDWIDTH_Value32NBO q_in;
3614   double pref_rel;
3615   double share;
3616   unsigned long long distributable;
3617   uint64_t need_per_peer;
3618   uint64_t need_per_second;
3619
3620 #if DEBUG_CORE
3621   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3622               "Neighbour quota update calculation running for peer `%4s'\n",
3623               GNUNET_i2s (&n->peer));
3624 #endif
3625   n->quota_update_task = GNUNET_SCHEDULER_NO_TASK;
3626   /* calculate relative preference among all neighbours;
3627      divides by a bit more to avoid division by zero AND to
3628      account for possibility of new neighbours joining any time
3629      AND to convert to double... */
3630   if (preference_sum == 0)
3631     {
3632       pref_rel = 1.0 / (double) neighbour_count;
3633     }
3634   else
3635     {
3636       pref_rel = n->current_preference / preference_sum;
3637     }
3638   need_per_peer = GNUNET_BANDWIDTH_value_get_available_until (MIN_BANDWIDTH_PER_PEER,
3639                                                               GNUNET_TIME_UNIT_SECONDS);
3640   need_per_second = need_per_peer * neighbour_count;
3641   distributable = 0;
3642   if (bandwidth_target_out_bps > need_per_second)
3643     distributable = bandwidth_target_out_bps - need_per_second;
3644   share = distributable * pref_rel;
3645   if (share + need_per_peer > UINT32_MAX)
3646     q_in = GNUNET_BANDWIDTH_value_init (UINT32_MAX);
3647   else
3648     q_in = GNUNET_BANDWIDTH_value_init (need_per_peer + (uint32_t) share);
3649   /* check if we want to disconnect for good due to inactivity */
3650   if ( (GNUNET_TIME_absolute_get_duration (n->last_activity).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) &&
3651        (GNUNET_TIME_absolute_get_duration (n->time_established).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) )
3652     {
3653 #if DEBUG_CORE
3654       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3655                   "Forcing disconnect of `%4s' due to inactivity\n",
3656                   GNUNET_i2s (&n->peer));
3657 #endif
3658       q_in = GNUNET_BANDWIDTH_value_init (0); /* force disconnect */
3659     }
3660 #if DEBUG_CORE_QUOTA
3661   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3662               "Current quota for `%4s' is %u/%llu b/s in (old: %u b/s) / %u out (%u internal)\n",
3663               GNUNET_i2s (&n->peer),
3664               (unsigned int) ntohl (q_in.value__),
3665               bandwidth_target_out_bps,
3666               (unsigned int) ntohl (n->bw_in.value__),
3667               (unsigned int) ntohl (n->bw_out.value__),
3668               (unsigned int) ntohl (n->bw_out_internal_limit.value__));
3669 #endif
3670   if (n->bw_in.value__ != q_in.value__)
3671     {
3672       n->bw_in = q_in;
3673       if (GNUNET_YES == n->is_connected)
3674         GNUNET_TRANSPORT_set_quota (transport,
3675                                     &n->peer,
3676                                     n->bw_in,
3677                                     n->bw_out,
3678                                     GNUNET_TIME_UNIT_FOREVER_REL,
3679                                     NULL, NULL);
3680       handle_peer_status_change (n);
3681     }
3682   schedule_quota_update (n);
3683 }
3684
3685
3686 /**
3687  * Function called by transport to notify us that
3688  * a peer connected to us (on the network level).
3689  *
3690  * @param cls closure
3691  * @param peer the peer that connected
3692  * @param latency current latency of the connection
3693  * @param distance in overlay hops, as given by transport plugin
3694  */
3695 static void
3696 handle_transport_notify_connect (void *cls,
3697                                  const struct GNUNET_PeerIdentity *peer,
3698                                  struct GNUNET_TIME_Relative latency,
3699                                  unsigned int distance)
3700 {
3701   struct Neighbour *n;
3702
3703   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3704     {
3705       GNUNET_break (0);
3706       return;
3707     }
3708   n = find_neighbour (peer);
3709   if (n != NULL)
3710     {
3711       if (GNUNET_YES == n->is_connected)
3712         {
3713           /* duplicate connect notification!? */
3714           GNUNET_break (0);
3715           return;
3716         }
3717     }
3718   else
3719     {
3720       n = create_neighbour (peer);
3721     }
3722   GNUNET_STATISTICS_update (stats,
3723                             gettext_noop ("# peers connected (transport)"),
3724                             1,
3725                             GNUNET_NO);
3726   n->is_connected = GNUNET_YES;
3727   n->last_latency = latency;
3728   n->last_distance = distance;
3729   GNUNET_BANDWIDTH_tracker_init (&n->available_send_window,
3730                                  n->bw_out,
3731                                  MAX_WINDOW_TIME_S);
3732   GNUNET_BANDWIDTH_tracker_init (&n->available_recv_window,
3733                                  n->bw_in,
3734                                  MAX_WINDOW_TIME_S);
3735 #if DEBUG_CORE
3736   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3737               "Received connection from `%4s'.\n",
3738               GNUNET_i2s (&n->peer));
3739 #endif
3740   GNUNET_TRANSPORT_set_quota (transport,
3741                               &n->peer,
3742                               n->bw_in,
3743                               n->bw_out,
3744                               GNUNET_TIME_UNIT_FOREVER_REL,
3745                               NULL, NULL);
3746   send_key (n);
3747 }
3748
3749
3750 /**
3751  * Function called by transport telling us that a peer
3752  * disconnected.
3753  *
3754  * @param cls closure
3755  * @param peer the peer that disconnected
3756  */
3757 static void
3758 handle_transport_notify_disconnect (void *cls,
3759                                     const struct GNUNET_PeerIdentity *peer)
3760 {
3761   struct DisconnectNotifyMessage cnm;
3762   struct Neighbour *n;
3763   struct GNUNET_TIME_Relative left;
3764
3765 #if DEBUG_CORE
3766   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3767               "Peer `%4s' disconnected from us.\n", GNUNET_i2s (peer));
3768 #endif
3769   n = find_neighbour (peer);
3770   if (n == NULL)
3771     {
3772       GNUNET_break (0);
3773       return;
3774     }
3775   GNUNET_break (n->is_connected);
3776   if (n->status == PEER_STATE_KEY_CONFIRMED)
3777     {
3778       cnm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
3779       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
3780       cnm.peer = *peer;
3781       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_DISCONNECT);
3782     }
3783   n->is_connected = GNUNET_NO;
3784   GNUNET_STATISTICS_update (stats,
3785                             gettext_noop ("# peers connected (transport)"),
3786                             -1,
3787                             GNUNET_NO);
3788   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
3789     GNUNET_SCHEDULER_cancel (sched,
3790                              n->dead_clean_task);
3791   left = GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
3792                                         GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
3793   n->last_activity = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (),
3794                                                     left);
3795   n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
3796                                                      GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
3797                                                      &consider_free_task,
3798                                                      n);
3799 }
3800
3801
3802 /**
3803  * Last task run during shutdown.  Disconnects us from
3804  * the transport.
3805  */
3806 static void
3807 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
3808 {
3809   struct Neighbour *n;
3810   struct Client *c;
3811
3812 #if DEBUG_CORE
3813   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3814               "Core service shutting down.\n");
3815 #endif
3816   GNUNET_assert (transport != NULL);
3817   GNUNET_TRANSPORT_disconnect (transport);
3818   transport = NULL;
3819   while (NULL != (n = neighbours))
3820     {
3821       neighbours = n->next;
3822       GNUNET_assert (neighbour_count > 0);
3823       neighbour_count--;
3824       free_neighbour (n);
3825     }
3826   GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), neighbour_count, GNUNET_NO);
3827   GNUNET_SERVER_notification_context_destroy (notifier);
3828   notifier = NULL;
3829   while (NULL != (c = clients))
3830     handle_client_disconnect (NULL, c->client_handle);
3831   if (my_private_key != NULL)
3832     GNUNET_CRYPTO_rsa_key_free (my_private_key);
3833   if (stats != NULL)
3834     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
3835   if (peerinfo != NULL)
3836     GNUNET_PEERINFO_disconnect (peerinfo);
3837   if (mst != NULL)
3838     GNUNET_SERVER_mst_destroy (mst);
3839 }
3840
3841
3842 /**
3843  * Initiate core service.
3844  *
3845  * @param cls closure
3846  * @param s scheduler to use
3847  * @param server the initialized server
3848  * @param c configuration to use
3849  */
3850 static void
3851 run (void *cls,
3852      struct GNUNET_SCHEDULER_Handle *s,
3853      struct GNUNET_SERVER_Handle *server,
3854      const struct GNUNET_CONFIGURATION_Handle *c)
3855 {
3856   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
3857     {&handle_client_init, NULL,
3858      GNUNET_MESSAGE_TYPE_CORE_INIT, 0},
3859     {&handle_client_request_info, NULL,
3860      GNUNET_MESSAGE_TYPE_CORE_REQUEST_INFO,
3861      sizeof (struct RequestInfoMessage)},
3862     {&handle_client_iterate_peers, NULL,
3863      GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS,
3864      sizeof (struct GNUNET_MessageHeader)},
3865     {&handle_client_send, NULL,
3866      GNUNET_MESSAGE_TYPE_CORE_SEND, 0},
3867     {&handle_client_request_connect, NULL,
3868      GNUNET_MESSAGE_TYPE_CORE_REQUEST_CONNECT,
3869      sizeof (struct ConnectMessage)},
3870     {NULL, NULL, 0, 0}
3871   };
3872   char *keyfile;
3873
3874   sched = s;
3875   cfg = c;
3876   /* parse configuration */
3877   if (
3878        (GNUNET_OK !=
3879         GNUNET_CONFIGURATION_get_value_number (c,
3880                                                "CORE",
3881                                                "TOTAL_QUOTA_IN",
3882                                                &bandwidth_target_in_bps)) ||
3883        (GNUNET_OK !=
3884         GNUNET_CONFIGURATION_get_value_number (c,
3885                                                "CORE",
3886                                                "TOTAL_QUOTA_OUT",
3887                                                &bandwidth_target_out_bps)) ||
3888        (GNUNET_OK !=
3889         GNUNET_CONFIGURATION_get_value_filename (c,
3890                                                  "GNUNETD",
3891                                                  "HOSTKEY", &keyfile)))
3892     {
3893       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3894                   _
3895                   ("Core service is lacking key configuration settings.  Exiting.\n"));
3896       GNUNET_SCHEDULER_shutdown (s);
3897       return;
3898     }
3899   peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
3900   if (NULL == peerinfo)
3901     {
3902       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3903                   _("Could not access PEERINFO service.  Exiting.\n"));
3904       GNUNET_SCHEDULER_shutdown (s);
3905       GNUNET_free (keyfile);
3906       return;
3907     }
3908   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
3909   GNUNET_free (keyfile);
3910   if (my_private_key == NULL)
3911     {
3912       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3913                   _("Core service could not access hostkey.  Exiting.\n"));
3914       GNUNET_PEERINFO_disconnect (peerinfo);
3915       GNUNET_SCHEDULER_shutdown (s);
3916       return;
3917     }
3918   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
3919   GNUNET_CRYPTO_hash (&my_public_key,
3920                       sizeof (my_public_key), &my_identity.hashPubKey);
3921   /* setup notification */
3922   notifier = GNUNET_SERVER_notification_context_create (server,
3923                                                         MAX_NOTIFY_QUEUE);
3924   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
3925   /* setup transport connection */
3926   transport = GNUNET_TRANSPORT_connect (sched,
3927                                         cfg,
3928                                         &my_identity,
3929                                         NULL,
3930                                         &handle_transport_receive,
3931                                         &handle_transport_notify_connect,
3932                                         &handle_transport_notify_disconnect);
3933   GNUNET_assert (NULL != transport);
3934   stats = GNUNET_STATISTICS_create (sched, "core", cfg);
3935   mst = GNUNET_SERVER_mst_create (&deliver_message,
3936                                   NULL);
3937   GNUNET_SCHEDULER_add_delayed (sched,
3938                                 GNUNET_TIME_UNIT_FOREVER_REL,
3939                                 &cleaning_task, NULL);
3940   /* process client requests */
3941   GNUNET_SERVER_add_handlers (server, handlers);
3942   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3943               _("Core service of `%4s' ready.\n"), GNUNET_i2s (&my_identity));
3944 }
3945
3946
3947
3948 /**
3949  * The main function for the transport service.
3950  *
3951  * @param argc number of arguments from the command line
3952  * @param argv command line arguments
3953  * @return 0 ok, 1 on error
3954  */
3955 int
3956 main (int argc, char *const *argv)
3957 {
3958   return (GNUNET_OK ==
3959           GNUNET_SERVICE_run (argc,
3960                               argv,
3961                               "core",
3962                               GNUNET_SERVICE_OPTION_NONE,
3963                               &run, NULL)) ? 0 : 1;
3964 }
3965
3966 /* end of gnunet-service-core.c */