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_YES
  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 n 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 at least %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   if (GNUNET_YES != n->is_connected)
2371     {
2372       /* transport should only call us to transmit a message after
2373        * telling us about a successful connection to the respective peer */
2374       n->th = NULL; /* If this happens because of a timeout, reset n-th so another message may be sent for this peer! */
2375 #if DEBUG_CORE
2376       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Timeout on notify connect!\n");
2377 #endif
2378       return 0;
2379     }
2380   n->th = NULL;
2381   if (buf == NULL)
2382     {
2383       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2384                   _("Failed to connect to `%4s': transport failed to connect\n"),
2385                   GNUNET_i2s (&n->peer));
2386       return 0;
2387     }
2388   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2389               _("TRANSPORT connection to peer `%4s' is up, trying to establish CORE connection\n"),
2390               GNUNET_i2s (&n->peer));
2391   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2392     GNUNET_SCHEDULER_cancel (sched,
2393                              n->retry_set_key_task);
2394   n->retry_set_key_task = GNUNET_SCHEDULER_add_now (sched,
2395                                                     &set_key_retry_task,
2396                                                     n);
2397   return 0;
2398 }
2399
2400
2401 /**
2402  * Handle CORE_REQUEST_CONNECT request.
2403  *
2404  * @param cls unused
2405  * @param client the client issuing the request
2406  * @param message the "struct ConnectMessage"
2407  */
2408 static void
2409 handle_client_request_connect (void *cls,
2410                                struct GNUNET_SERVER_Client *client,
2411                                const struct GNUNET_MessageHeader *message)
2412 {
2413   const struct ConnectMessage *cm = (const struct ConnectMessage*) message;
2414   struct Neighbour *n;
2415   struct GNUNET_TIME_Relative timeout;
2416
2417   if (0 == memcmp (&cm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2418     {
2419       GNUNET_break (0);
2420       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2421       return;
2422     }
2423   GNUNET_SERVER_receive_done (client, GNUNET_OK);
2424   n = find_neighbour (&cm->peer);
2425   if (n == NULL)
2426     n = create_neighbour (&cm->peer);
2427   if ( (GNUNET_YES == n->is_connected) ||
2428        (n->th != NULL) )
2429     {
2430       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2431                  "Core received `%s' request for `%4s', already connected!\n",
2432                  "REQUEST_CONNECT",
2433                  GNUNET_i2s (&cm->peer));
2434       return; /* already connected, or at least trying */
2435     }
2436   GNUNET_STATISTICS_update (stats, gettext_noop ("# connection requests received"), 1, GNUNET_NO);
2437
2438   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2439               "Core received `%s' request for `%4s', will try to establish connection\n",
2440               "REQUEST_CONNECT",
2441               GNUNET_i2s (&cm->peer));
2442
2443   timeout = GNUNET_TIME_relative_ntoh (cm->timeout);
2444   /* ask transport to connect to the peer */
2445   n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2446                                                   &cm->peer,
2447                                                   sizeof (struct GNUNET_MessageHeader), 0,
2448                                                   timeout,
2449                                                   &notify_transport_connect_done,
2450                                                   n);
2451   GNUNET_break (NULL != n->th);
2452 }
2453
2454
2455 /**
2456  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2457  * the neighbour's struct and retry send_key.  Or, if we did not get a
2458  * HELLO, just do nothing.
2459  *
2460  * @param cls the 'struct Neighbour' to retry sending the key for
2461  * @param peer the peer for which this is the HELLO
2462  * @param hello HELLO message of that peer
2463  */
2464 static void
2465 process_hello_retry_send_key (void *cls,
2466                               const struct GNUNET_PeerIdentity *peer,
2467                               const struct GNUNET_HELLO_Message *hello)
2468 {
2469   struct Neighbour *n = cls;
2470
2471   if (peer == NULL)
2472     {
2473 #if DEBUG_CORE
2474       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2475                   "Entered `%s' and `%s' is NULL!\n",
2476                   "process_hello_retry_send_key",
2477                   "peer");
2478 #endif
2479       n->pitr = NULL;
2480       if (n->public_key != NULL)
2481         {
2482           if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2483             {
2484               GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2485               n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2486             }
2487           GNUNET_STATISTICS_update (stats,
2488                                     gettext_noop ("# SET_KEY messages deferred (need public key)"),
2489                                     -1,
2490                                     GNUNET_NO);
2491           send_key (n);
2492         }
2493       else
2494         {
2495 #if DEBUG_CORE
2496           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2497                       "Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n",
2498                       GNUNET_i2s (&n->peer));
2499 #endif
2500           GNUNET_STATISTICS_update (stats,
2501                                     gettext_noop ("# Delayed connecting due to lack of public key"),
2502                                     1,
2503                                     GNUNET_NO);
2504           if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
2505             n->retry_set_key_task
2506               = GNUNET_SCHEDULER_add_delayed (sched,
2507                                               n->set_key_retry_frequency,
2508                                               &set_key_retry_task, n);
2509         }
2510       return;
2511     }
2512
2513 #if DEBUG_CORE
2514   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2515               "Entered `%s' for peer `%4s'\n",
2516               "process_hello_retry_send_key",
2517               GNUNET_i2s (peer));
2518 #endif
2519   if (n->public_key != NULL)
2520     {
2521       /* already have public key, why are we here? */
2522       GNUNET_break (0);
2523       return;
2524     }
2525
2526 #if DEBUG_CORE
2527   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2528               "Received new `%s' message for `%4s', initiating key exchange.\n",
2529               "HELLO",
2530               GNUNET_i2s (peer));
2531 #endif
2532   n->public_key =
2533     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2534   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2535     {
2536       GNUNET_STATISTICS_update (stats,
2537                                 gettext_noop ("# Error extracting public key from HELLO"),
2538                                 1,
2539                                 GNUNET_NO);
2540       GNUNET_free (n->public_key);
2541       n->public_key = NULL;
2542 #if DEBUG_CORE
2543   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2544               "GNUNET_HELLO_get_key returned awfully\n");
2545 #endif
2546       return;
2547     }
2548 }
2549
2550
2551 /**
2552  * Send our key (and encrypted PING) to the other peer.
2553  *
2554  * @param n the other peer
2555  */
2556 static void
2557 send_key (struct Neighbour *n)
2558 {
2559   struct MessageEntry *pos;
2560   struct SetKeyMessage *sm;
2561   struct MessageEntry *me;
2562   struct PingMessage pp;
2563   struct PingMessage *pm;
2564
2565   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2566     {
2567       GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2568       n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2569     }
2570   if (n->pitr != NULL)
2571     {
2572 #if DEBUG_CORE
2573       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2574                   "Key exchange in progress with `%4s'.\n",
2575                   GNUNET_i2s (&n->peer));
2576 #endif
2577       return; /* already in progress */
2578     }
2579   if (GNUNET_YES != n->is_connected)
2580     {
2581 #if DEBUG_CORE
2582       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2583                   "Not yet connected to peer `%4s'!\n",
2584                   GNUNET_i2s (&n->peer));
2585 #endif
2586       if (NULL == n->th)
2587         {
2588           GNUNET_STATISTICS_update (stats,
2589                                     gettext_noop ("# Asking transport to connect (for SET_KEY)"),
2590                                     1,
2591                                     GNUNET_NO);
2592           n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2593                                                           &n->peer,
2594                                                           sizeof (struct SetKeyMessage) + sizeof (struct PingMessage),
2595                                                           0,
2596                                                           GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2597                                                           &notify_encrypted_transmit_ready,
2598                                                           n);
2599         }
2600       return;
2601     }
2602 #if DEBUG_CORE
2603   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2604               "Asked to perform key exchange with `%4s'.\n",
2605               GNUNET_i2s (&n->peer));
2606 #endif
2607   if (n->public_key == NULL)
2608     {
2609       /* lookup n's public key, then try again */
2610 #if DEBUG_CORE
2611       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2612                   "Lacking public key for `%4s', trying to obtain one (send_key).\n",
2613                   GNUNET_i2s (&n->peer));
2614 #endif
2615       GNUNET_assert (n->pitr == NULL);
2616       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
2617                                          &n->peer,
2618                                          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20),
2619                                          &process_hello_retry_send_key, n);
2620       return;
2621     }
2622   pos = n->encrypted_head;
2623   while (pos != NULL)
2624     {
2625       if (GNUNET_YES == pos->is_setkey)
2626         {
2627           if (pos->sender_status == n->status)
2628             {
2629 #if DEBUG_CORE
2630               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2631                           "`%s' message for `%4s' queued already\n",
2632                           "SET_KEY",
2633                           GNUNET_i2s (&n->peer));
2634 #endif
2635               goto trigger_processing;
2636             }
2637           GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
2638                                        n->encrypted_tail,
2639                                        pos);
2640           GNUNET_free (pos);
2641 #if DEBUG_CORE
2642           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2643                       "Removing queued `%s' message for `%4s', will create a new one\n",
2644                       "SET_KEY",
2645                       GNUNET_i2s (&n->peer));
2646 #endif
2647           break;
2648         }
2649       pos = pos->next;
2650     }
2651
2652   /* update status */
2653   switch (n->status)
2654     {
2655     case PEER_STATE_DOWN:
2656       n->status = PEER_STATE_KEY_SENT;
2657       break;
2658     case PEER_STATE_KEY_SENT:
2659       break;
2660     case PEER_STATE_KEY_RECEIVED:
2661       break;
2662     case PEER_STATE_KEY_CONFIRMED:
2663       break;
2664     default:
2665       GNUNET_break (0);
2666       break;
2667     }
2668
2669
2670   /* first, set key message */
2671   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2672                       sizeof (struct SetKeyMessage) +
2673                       sizeof (struct PingMessage));
2674   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_SET_KEY_DELAY);
2675   me->priority = SET_KEY_PRIORITY;
2676   me->size = sizeof (struct SetKeyMessage) + sizeof (struct PingMessage);
2677   me->is_setkey = GNUNET_YES;
2678   me->got_slack = GNUNET_YES; /* do not defer this one! */
2679   me->sender_status = n->status;
2680   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2681                                      n->encrypted_tail,
2682                                      n->encrypted_tail,
2683                                      me);
2684   sm = (struct SetKeyMessage *) &me[1];
2685   sm->header.size = htons (sizeof (struct SetKeyMessage));
2686   sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SET_KEY);
2687   sm->sender_status = htonl ((int32_t) ((n->status == PEER_STATE_DOWN) ?
2688                                         PEER_STATE_KEY_SENT : n->status));
2689   sm->purpose.size =
2690     htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
2691            sizeof (struct GNUNET_TIME_AbsoluteNBO) +
2692            sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
2693            sizeof (struct GNUNET_PeerIdentity));
2694   sm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SET_KEY);
2695   sm->creation_time = GNUNET_TIME_absolute_hton (n->encrypt_key_created);
2696   sm->target = n->peer;
2697   GNUNET_assert (GNUNET_OK ==
2698                  GNUNET_CRYPTO_rsa_encrypt (&n->encrypt_key,
2699                                             sizeof (struct
2700                                                     GNUNET_CRYPTO_AesSessionKey),
2701                                             n->public_key,
2702                                             &sm->encrypted_key));
2703   GNUNET_assert (GNUNET_OK ==
2704                  GNUNET_CRYPTO_rsa_sign (my_private_key, &sm->purpose,
2705                                          &sm->signature));
2706   pm = (struct PingMessage *) &sm[1];
2707   pm->header.size = htons (sizeof (struct PingMessage));
2708   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
2709   pp.challenge = htonl (n->ping_challenge);
2710   pp.target = n->peer;
2711 #if DEBUG_HANDSHAKE
2712   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2713               "Encrypting `%s' and `%s' messages with challenge %u for `%4s' using key %u.\n",
2714               "SET_KEY", "PING",
2715               (unsigned int) n->ping_challenge,
2716               GNUNET_i2s (&n->peer),
2717               (unsigned int) n->encrypt_key.crc32);
2718 #endif
2719   do_encrypt (n,
2720               &n->peer.hashPubKey,
2721               &pp.challenge,
2722               &pm->challenge,
2723               sizeof (struct PingMessage) -
2724               sizeof (struct GNUNET_MessageHeader));
2725   GNUNET_STATISTICS_update (stats,
2726                             gettext_noop ("# SET_KEY and PING messages created"),
2727                             1,
2728                             GNUNET_NO);
2729 #if DEBUG_CORE
2730   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2731               "Have %llu ms left for `%s' transmission.\n",
2732               (unsigned long long) GNUNET_TIME_absolute_get_remaining (me->deadline).value,
2733               "SET_KEY");
2734 #endif
2735  trigger_processing:
2736   /* trigger queue processing */
2737   process_encrypted_neighbour_queue (n);
2738   if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
2739        (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
2740     n->retry_set_key_task
2741       = GNUNET_SCHEDULER_add_delayed (sched,
2742                                       n->set_key_retry_frequency,
2743                                       &set_key_retry_task, n);
2744 }
2745
2746
2747 /**
2748  * We received a SET_KEY message.  Validate and update
2749  * our key material and status.
2750  *
2751  * @param n the neighbour from which we received message m
2752  * @param m the set key message we received
2753  */
2754 static void
2755 handle_set_key (struct Neighbour *n,
2756                 const struct SetKeyMessage *m);
2757
2758
2759 /**
2760  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2761  * the neighbour's struct and retry handling the set_key message.  Or,
2762  * if we did not get a HELLO, just free the set key message.
2763  *
2764  * @param cls pointer to the set key message
2765  * @param peer the peer for which this is the HELLO
2766  * @param hello HELLO message of that peer
2767  */
2768 static void
2769 process_hello_retry_handle_set_key (void *cls,
2770                                     const struct GNUNET_PeerIdentity *peer,
2771                                     const struct GNUNET_HELLO_Message *hello)
2772 {
2773   struct Neighbour *n = cls;
2774   struct SetKeyMessage *sm = n->skm;
2775
2776   if (peer == NULL)
2777     {
2778       n->skm = NULL;
2779       n->pitr = NULL;
2780       if (n->public_key != NULL)
2781         {
2782 #if DEBUG_CORE
2783           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2784                       "Received `%s' for `%4s', continuing processing of `%s' message.\n",
2785                       "HELLO",
2786                       GNUNET_i2s (&n->peer),
2787                       "SET_KEY");
2788 #endif
2789           handle_set_key (n, sm);
2790         }
2791       else
2792         {
2793           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2794                       _("Ignoring `%s' message due to lack of public key for peer `%4s' (failed to obtain one).\n"),
2795                       "SET_KEY",
2796                       GNUNET_i2s (&n->peer));
2797         }
2798       GNUNET_free (sm);
2799       return;
2800     }
2801   if (n->public_key != NULL)
2802     return;                     /* multiple HELLOs match!? */
2803   n->public_key =
2804     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2805   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2806     {
2807       GNUNET_break_op (0);
2808       GNUNET_free (n->public_key);
2809       n->public_key = NULL;
2810     }
2811 }
2812
2813
2814 /**
2815  * We received a PING message.  Validate and transmit
2816  * PONG.
2817  *
2818  * @param n sender of the PING
2819  * @param m the encrypted PING message itself
2820  */
2821 static void
2822 handle_ping (struct Neighbour *n, const struct PingMessage *m)
2823 {
2824   struct PingMessage t;
2825   struct PongMessage tx;
2826   struct PongMessage *tp;
2827   struct MessageEntry *me;
2828
2829 #if DEBUG_CORE
2830   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2831               "Core service receives `%s' request from `%4s'.\n",
2832               "PING", GNUNET_i2s (&n->peer));
2833 #endif
2834   if (GNUNET_OK !=
2835       do_decrypt (n,
2836                   &my_identity.hashPubKey,
2837                   &m->challenge,
2838                   &t.challenge,
2839                   sizeof (struct PingMessage) -
2840                   sizeof (struct GNUNET_MessageHeader)))
2841     return;
2842 #if DEBUG_HANDSHAKE
2843   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2844               "Decrypted `%s' to `%4s' with challenge %u decrypted using key %u\n",
2845               "PING",
2846               GNUNET_i2s (&t.target),
2847               (unsigned int) ntohl (t.challenge),
2848               (unsigned int) n->decrypt_key.crc32);
2849 #endif
2850   GNUNET_STATISTICS_update (stats,
2851                             gettext_noop ("# PING messages decrypted"),
2852                             1,
2853                             GNUNET_NO);
2854   if (0 != memcmp (&t.target,
2855                    &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2856     {
2857       GNUNET_break_op (0);
2858       return;
2859     }
2860   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2861                       sizeof (struct PongMessage));
2862   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2863                                      n->encrypted_tail,
2864                                      n->encrypted_tail,
2865                                      me);
2866   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PONG_DELAY);
2867   me->priority = PONG_PRIORITY;
2868   me->size = sizeof (struct PongMessage);
2869   tx.reserved = htonl (0);
2870   tx.inbound_bw_limit = n->bw_in;
2871   tx.challenge = t.challenge;
2872   tx.target = t.target;
2873   tp = (struct PongMessage *) &me[1];
2874   tp->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PONG);
2875   tp->header.size = htons (sizeof (struct PongMessage));
2876   do_encrypt (n,
2877               &my_identity.hashPubKey,
2878               &tx.challenge,
2879               &tp->challenge,
2880               sizeof (struct PongMessage) -
2881               sizeof (struct GNUNET_MessageHeader));
2882   GNUNET_STATISTICS_update (stats,
2883                             gettext_noop ("# PONG messages created"),
2884                             1,
2885                             GNUNET_NO);
2886 #if DEBUG_HANDSHAKE
2887   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2888               "Encrypting `%s' with challenge %u using key %u\n",
2889               "PONG",
2890               (unsigned int) ntohl (t.challenge),
2891               (unsigned int) n->encrypt_key.crc32);
2892 #endif
2893   /* trigger queue processing */
2894   process_encrypted_neighbour_queue (n);
2895 }
2896
2897
2898 /**
2899  * We received a PONG message.  Validate and update our status.
2900  *
2901  * @param n sender of the PONG
2902  * @param m the encrypted PONG message itself
2903  */
2904 static void
2905 handle_pong (struct Neighbour *n,
2906              const struct PongMessage *m)
2907 {
2908   struct PongMessage t;
2909   struct ConnectNotifyMessage cnm;
2910
2911 #if DEBUG_CORE
2912   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2913               "Core service receives `%s' response from `%4s'.\n",
2914               "PONG", GNUNET_i2s (&n->peer));
2915 #endif
2916   /* mark as garbage, just to be sure */
2917   memset (&t, 255, sizeof (t));
2918   if (GNUNET_OK !=
2919       do_decrypt (n,
2920                   &n->peer.hashPubKey,
2921                   &m->challenge,
2922                   &t.challenge,
2923                   sizeof (struct PongMessage) -
2924                   sizeof (struct GNUNET_MessageHeader)))
2925     {
2926       GNUNET_break_op (0);
2927       return;
2928     }
2929   GNUNET_STATISTICS_update (stats,
2930                             gettext_noop ("# PONG messages decrypted"),
2931                             1,
2932                             GNUNET_NO);
2933   if (0 != ntohl (t.reserved))
2934     {
2935       GNUNET_break_op (0);
2936       return;
2937     }
2938 #if DEBUG_HANDSHAKE
2939   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2940               "Decrypted `%s' from `%4s' with challenge %u using key %u\n",
2941               "PONG",
2942               GNUNET_i2s (&t.target),
2943               (unsigned int) ntohl (t.challenge),
2944               (unsigned int) n->decrypt_key.crc32);
2945 #endif
2946   if ((0 != memcmp (&t.target,
2947                     &n->peer,
2948                     sizeof (struct GNUNET_PeerIdentity))) ||
2949       (n->ping_challenge != ntohl (t.challenge)))
2950     {
2951       /* PONG malformed */
2952 #if DEBUG_CORE
2953       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2954                   "Received malformed `%s' wanted sender `%4s' with challenge %u\n",
2955                   "PONG",
2956                   GNUNET_i2s (&n->peer),
2957                   (unsigned int) n->ping_challenge);
2958       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2959                   "Received malformed `%s' received from `%4s' with challenge %u\n",
2960                   "PONG", GNUNET_i2s (&t.target),
2961                   (unsigned int) ntohl (t.challenge));
2962 #endif
2963       GNUNET_break_op (0);
2964       return;
2965     }
2966   switch (n->status)
2967     {
2968     case PEER_STATE_DOWN:
2969       GNUNET_break (0);         /* should be impossible */
2970       return;
2971     case PEER_STATE_KEY_SENT:
2972       GNUNET_break (0);         /* should be impossible, how did we decrypt? */
2973       return;
2974     case PEER_STATE_KEY_RECEIVED:
2975       GNUNET_STATISTICS_update (stats,
2976                                 gettext_noop ("# Session keys confirmed via PONG"),
2977                                 1,
2978                                 GNUNET_NO);
2979       n->status = PEER_STATE_KEY_CONFIRMED;
2980       if (n->bw_out_external_limit.value__ != t.inbound_bw_limit.value__)
2981         {
2982           n->bw_out_external_limit = t.inbound_bw_limit;
2983           n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
2984                                                   n->bw_out_internal_limit);
2985           GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
2986                                                  n->bw_out);
2987           GNUNET_TRANSPORT_set_quota (transport,
2988                                       &n->peer,
2989                                       n->bw_in,
2990                                       n->bw_out,
2991                                       GNUNET_TIME_UNIT_FOREVER_REL,
2992                                       NULL, NULL);
2993         }
2994 #if DEBUG_CORE
2995       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2996                   "Confirmed key via `%s' message for peer `%4s'\n",
2997                   "PONG", GNUNET_i2s (&n->peer));
2998 #endif
2999       if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
3000         {
3001           GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
3002           n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
3003         }
3004       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
3005       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
3006       cnm.distance = htonl (n->last_distance);
3007       cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
3008       cnm.peer = n->peer;
3009       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_CONNECT);
3010       process_encrypted_neighbour_queue (n);
3011       /* fall-through! */
3012     case PEER_STATE_KEY_CONFIRMED:
3013       n->last_activity = GNUNET_TIME_absolute_get ();
3014       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3015         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3016       n->keep_alive_task
3017         = GNUNET_SCHEDULER_add_delayed (sched,
3018                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3019                                         &send_keep_alive,
3020                                         n);
3021       handle_peer_status_change (n);
3022       break;
3023     default:
3024       GNUNET_break (0);
3025       break;
3026     }
3027 }
3028
3029
3030 /**
3031  * We received a SET_KEY message.  Validate and update
3032  * our key material and status.
3033  *
3034  * @param n the neighbour from which we received message m
3035  * @param m the set key message we received
3036  */
3037 static void
3038 handle_set_key (struct Neighbour *n, const struct SetKeyMessage *m)
3039 {
3040   struct SetKeyMessage *m_cpy;
3041   struct GNUNET_TIME_Absolute t;
3042   struct GNUNET_CRYPTO_AesSessionKey k;
3043   struct PingMessage *ping;
3044   struct PongMessage *pong;
3045   enum PeerStateMachine sender_status;
3046
3047 #if DEBUG_CORE
3048   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3049               "Core service receives `%s' request from `%4s'.\n",
3050               "SET_KEY", GNUNET_i2s (&n->peer));
3051 #endif
3052   if (n->public_key == NULL)
3053     {
3054       if (n->pitr != NULL)
3055         {
3056 #if DEBUG_CORE
3057           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3058                       "Ignoring `%s' message due to lack of public key for peer (still trying to obtain one).\n",
3059                       "SET_KEY");
3060 #endif
3061           return;
3062         }
3063 #if DEBUG_CORE
3064       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3065                   "Lacking public key for peer, trying to obtain one (handle_set_key).\n");
3066 #endif
3067       m_cpy = GNUNET_malloc (sizeof (struct SetKeyMessage));
3068       memcpy (m_cpy, m, sizeof (struct SetKeyMessage));
3069       /* lookup n's public key, then try again */
3070       GNUNET_assert (n->skm == NULL);
3071       n->skm = m_cpy;
3072       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
3073                                          &n->peer,
3074                                          GNUNET_TIME_UNIT_MINUTES,
3075                                          &process_hello_retry_handle_set_key, n);
3076       GNUNET_STATISTICS_update (stats,
3077                                 gettext_noop ("# SET_KEY messages deferred (need public key)"),
3078                                 1,
3079                                 GNUNET_NO);
3080       return;
3081     }
3082   if (0 != memcmp (&m->target,
3083                    &my_identity,
3084                    sizeof (struct GNUNET_PeerIdentity)))
3085     {
3086       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3087                   _("Received `%s' message that was for `%s', not for me.  Ignoring.\n"),
3088                   "SET_KEY",
3089                   GNUNET_i2s (&m->target));
3090       return;
3091     }
3092   if ((ntohl (m->purpose.size) !=
3093        sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
3094        sizeof (struct GNUNET_TIME_AbsoluteNBO) +
3095        sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
3096        sizeof (struct GNUNET_PeerIdentity)) ||
3097       (GNUNET_OK !=
3098        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_SET_KEY,
3099                                  &m->purpose, &m->signature, n->public_key)))
3100     {
3101       /* invalid signature */
3102       GNUNET_break_op (0);
3103       return;
3104     }
3105   t = GNUNET_TIME_absolute_ntoh (m->creation_time);
3106   if (((n->status == PEER_STATE_KEY_RECEIVED) ||
3107        (n->status == PEER_STATE_KEY_CONFIRMED)) &&
3108       (t.value < n->decrypt_key_created.value))
3109     {
3110       /* this could rarely happen due to massive re-ordering of
3111          messages on the network level, but is most likely either
3112          a bug or some adversary messing with us.  Report. */
3113       GNUNET_break_op (0);
3114       return;
3115     }
3116 #if DEBUG_CORE
3117   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3118               "Decrypting key material.\n");
3119 #endif
3120   if ((GNUNET_CRYPTO_rsa_decrypt (my_private_key,
3121                                   &m->encrypted_key,
3122                                   &k,
3123                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey))
3124        != sizeof (struct GNUNET_CRYPTO_AesSessionKey)) ||
3125       (GNUNET_OK != GNUNET_CRYPTO_aes_check_session_key (&k)))
3126     {
3127       /* failed to decrypt !? */
3128       GNUNET_break_op (0);
3129       return;
3130     }
3131   GNUNET_STATISTICS_update (stats,
3132                             gettext_noop ("# SET_KEY messages decrypted"),
3133                             1,
3134                             GNUNET_NO);
3135   n->decrypt_key = k;
3136   if (n->decrypt_key_created.value != t.value)
3137     {
3138       /* fresh key, reset sequence numbers */
3139       n->last_sequence_number_received = 0;
3140       n->last_packets_bitmap = 0;
3141       n->decrypt_key_created = t;
3142     }
3143   sender_status = (enum PeerStateMachine) ntohl (m->sender_status);
3144   switch (n->status)
3145     {
3146     case PEER_STATE_DOWN:
3147       n->status = PEER_STATE_KEY_RECEIVED;
3148 #if DEBUG_CORE
3149       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3150                   "Responding to `%s' with my own key.\n", "SET_KEY");
3151 #endif
3152       send_key (n);
3153       break;
3154     case PEER_STATE_KEY_SENT:
3155     case PEER_STATE_KEY_RECEIVED:
3156       n->status = PEER_STATE_KEY_RECEIVED;
3157       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3158           (sender_status != PEER_STATE_KEY_CONFIRMED))
3159         {
3160 #if DEBUG_CORE
3161           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3162                       "Responding to `%s' with my own key (other peer has status %u).\n",
3163                       "SET_KEY",
3164                       (unsigned int) sender_status);
3165 #endif
3166           send_key (n);
3167         }
3168       break;
3169     case PEER_STATE_KEY_CONFIRMED:
3170       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3171           (sender_status != PEER_STATE_KEY_CONFIRMED))
3172         {
3173 #if DEBUG_CORE
3174           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3175                       "Responding to `%s' with my own key (other peer has status %u), I was already fully up.\n",
3176                       "SET_KEY",
3177                       (unsigned int) sender_status);
3178 #endif
3179           send_key (n);
3180         }
3181       break;
3182     default:
3183       GNUNET_break (0);
3184       break;
3185     }
3186   if (n->pending_ping != NULL)
3187     {
3188       ping = n->pending_ping;
3189       n->pending_ping = NULL;
3190       handle_ping (n, ping);
3191       GNUNET_free (ping);
3192     }
3193   if (n->pending_pong != NULL)
3194     {
3195       pong = n->pending_pong;
3196       n->pending_pong = NULL;
3197       handle_pong (n, pong);
3198       GNUNET_free (pong);
3199     }
3200 }
3201
3202
3203 /**
3204  * Send a P2P message to a client.
3205  *
3206  * @param sender who sent us the message?
3207  * @param client who should we give the message to?
3208  * @param m contains the message to transmit
3209  * @param msize number of bytes in buf to transmit
3210  */
3211 static void
3212 send_p2p_message_to_client (struct Neighbour *sender,
3213                             struct Client *client,
3214                             const void *m, size_t msize)
3215 {
3216   char buf[msize + sizeof (struct NotifyTrafficMessage)];
3217   struct NotifyTrafficMessage *ntm;
3218
3219 #if DEBUG_CORE
3220   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3221               "Core service passes message from `%4s' of type %u to client.\n",
3222               GNUNET_i2s(&sender->peer),
3223               (unsigned int) ntohs (((const struct GNUNET_MessageHeader *) m)->type));
3224 #endif
3225   ntm = (struct NotifyTrafficMessage *) buf;
3226   ntm->header.size = htons (msize + sizeof (struct NotifyTrafficMessage));
3227   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND);
3228   ntm->distance = htonl (sender->last_distance);
3229   ntm->latency = GNUNET_TIME_relative_hton (sender->last_latency);
3230   ntm->peer = sender->peer;
3231   memcpy (&ntm[1], m, msize);
3232   send_to_client (client, &ntm->header, GNUNET_YES);
3233 }
3234
3235
3236 /**
3237  * Deliver P2P message to interested clients.
3238  *
3239  * @param cls always NULL
3240  * @param client who sent us the message (struct Neighbour)
3241  * @param m the message
3242  */
3243 static void
3244 deliver_message (void *cls,
3245                  void *client,
3246                  const struct GNUNET_MessageHeader *m)
3247 {
3248   struct Neighbour *sender = client;
3249   size_t msize = ntohs (m->size);
3250   char buf[256];
3251   struct Client *cpos;
3252   uint16_t type;
3253   unsigned int tpos;
3254   int deliver_full;
3255   int dropped;
3256
3257   type = ntohs (m->type);
3258 #if DEBUG_CORE
3259   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3260               "Received encapsulated message of type %u and size %u from `%4s'\n",
3261               (unsigned int) type,
3262               ntohs (m->size),
3263               GNUNET_i2s (&sender->peer));
3264 #endif
3265   GNUNET_snprintf (buf,
3266                    sizeof(buf),
3267                    gettext_noop ("# bytes of messages of type %u received"),
3268                    (unsigned int) type);
3269   GNUNET_STATISTICS_set (stats,
3270                          buf,
3271                          msize,
3272                          GNUNET_NO);
3273   dropped = GNUNET_YES;
3274   cpos = clients;
3275   while (cpos != NULL)
3276     {
3277       deliver_full = GNUNET_NO;
3278       if (0 != (cpos->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
3279         deliver_full = GNUNET_YES;
3280       else
3281         {
3282           for (tpos = 0; tpos < cpos->tcnt; tpos++)
3283             {
3284               if (type != cpos->types[tpos])
3285                 continue;
3286               deliver_full = GNUNET_YES;
3287               break;
3288             }
3289         }
3290       if (GNUNET_YES == deliver_full)
3291         {
3292           send_p2p_message_to_client (sender, cpos, m, msize);
3293           dropped = GNUNET_NO;
3294         }
3295       else if (cpos->options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)
3296         {
3297           send_p2p_message_to_client (sender, cpos, m,
3298                                       sizeof (struct GNUNET_MessageHeader));
3299         }
3300       cpos = cpos->next;
3301     }
3302   if (dropped == GNUNET_YES)
3303     {
3304 #if DEBUG_CORE
3305       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3306                   "Message of type %u from `%4s' not delivered to any client.\n",
3307                   (unsigned int) type,
3308                   GNUNET_i2s (&sender->peer));
3309 #endif
3310       GNUNET_STATISTICS_update (stats,
3311                                 gettext_noop ("# messages not delivered to any client"),
3312                                 1, GNUNET_NO);
3313     }
3314 }
3315
3316
3317 /**
3318  * We received an encrypted message.  Decrypt, validate and
3319  * pass on to the appropriate clients.
3320  */
3321 static void
3322 handle_encrypted_message (struct Neighbour *n,
3323                           const struct EncryptedMessage *m)
3324 {
3325   size_t size = ntohs (m->header.size);
3326   char buf[size];
3327   struct EncryptedMessage *pt;  /* plaintext */
3328   GNUNET_HashCode ph;
3329   uint32_t snum;
3330   struct GNUNET_TIME_Absolute t;
3331   GNUNET_HashCode iv;
3332
3333 #if DEBUG_CORE
3334   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3335               "Core service receives `%s' request from `%4s'.\n",
3336               "ENCRYPTED_MESSAGE", GNUNET_i2s (&n->peer));
3337 #endif
3338   GNUNET_CRYPTO_hash (&m->iv_seed, sizeof (uint32_t), &iv);
3339   /* decrypt */
3340   if (GNUNET_OK !=
3341       do_decrypt (n,
3342                   &iv,
3343                   &m->hmac,
3344                   &buf[ENCRYPTED_HEADER_SIZE],
3345                   size - ENCRYPTED_HEADER_SIZE))
3346     return;
3347   pt = (struct EncryptedMessage *) buf;
3348   /* validate hash */
3349   GNUNET_CRYPTO_hmac (&n->decrypt_key,
3350                       &pt->sequence_number,
3351                       size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode), &ph);
3352 #if DEBUG_HANDSHAKE
3353   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3354               "V-Hashed %u bytes of plaintext (`%s') using IV `%d'\n",
3355               (unsigned int) (size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode)),
3356               GNUNET_h2s (&ph),
3357               (int) m->iv_seed);
3358 #endif
3359   if (0 != memcmp (&ph,
3360                    &pt->hmac,
3361                    sizeof (GNUNET_HashCode)))
3362     {
3363       /* checksum failed */
3364       GNUNET_break_op (0);
3365       return;
3366     }
3367
3368   /* validate sequence number */
3369   snum = ntohl (pt->sequence_number);
3370   if (n->last_sequence_number_received == snum)
3371     {
3372       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3373                   "Received duplicate message, ignoring.\n");
3374       /* duplicate, ignore */
3375       GNUNET_STATISTICS_set (stats,
3376                              gettext_noop ("# bytes dropped (duplicates)"),
3377                              size,
3378                              GNUNET_NO);
3379       return;
3380     }
3381   if ((n->last_sequence_number_received > snum) &&
3382       (n->last_sequence_number_received - snum > 32))
3383     {
3384       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3385                   "Received ancient out of sequence message, ignoring.\n");
3386       /* ancient out of sequence, ignore */
3387       GNUNET_STATISTICS_set (stats,
3388                              gettext_noop ("# bytes dropped (out of sequence)"),
3389                              size,
3390                              GNUNET_NO);
3391       return;
3392     }
3393   if (n->last_sequence_number_received > snum)
3394     {
3395       unsigned int rotbit =
3396         1 << (n->last_sequence_number_received - snum - 1);
3397       if ((n->last_packets_bitmap & rotbit) != 0)
3398         {
3399           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3400                       "Received duplicate message, ignoring.\n");
3401           GNUNET_STATISTICS_set (stats,
3402                                  gettext_noop ("# bytes dropped (duplicates)"),
3403                                  size,
3404                                  GNUNET_NO);
3405           /* duplicate, ignore */
3406           return;
3407         }
3408       n->last_packets_bitmap |= rotbit;
3409     }
3410   if (n->last_sequence_number_received < snum)
3411     {
3412       n->last_packets_bitmap <<= (snum - n->last_sequence_number_received);
3413       n->last_sequence_number_received = snum;
3414     }
3415
3416   /* check timestamp */
3417   t = GNUNET_TIME_absolute_ntoh (pt->timestamp);
3418   if (GNUNET_TIME_absolute_get_duration (t).value > MAX_MESSAGE_AGE.value)
3419     {
3420       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3421                   _
3422                   ("Message received far too old (%llu ms). Content ignored.\n"),
3423                   GNUNET_TIME_absolute_get_duration (t).value);
3424       GNUNET_STATISTICS_set (stats,
3425                              gettext_noop ("# bytes dropped (ancient message)"),
3426                              size,
3427                              GNUNET_NO);
3428       return;
3429     }
3430
3431   /* process decrypted message(s) */
3432   if (n->bw_out_external_limit.value__ != pt->inbound_bw_limit.value__)
3433     {
3434 #if DEBUG_CORE_SET_QUOTA
3435       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3436                   "Received %u b/s as new inbound limit for peer `%4s'\n",
3437                   (unsigned int) ntohl (pt->inbound_bw_limit.value__),
3438                   GNUNET_i2s (&n->peer));
3439 #endif
3440       n->bw_out_external_limit = pt->inbound_bw_limit;
3441       n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
3442                                               n->bw_out_internal_limit);
3443       GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
3444                                              n->bw_out);
3445       GNUNET_TRANSPORT_set_quota (transport,
3446                                   &n->peer,
3447                                   n->bw_in,
3448                                   n->bw_out,
3449                                   GNUNET_TIME_UNIT_FOREVER_REL,
3450                                   NULL, NULL);
3451     }
3452   n->last_activity = GNUNET_TIME_absolute_get ();
3453   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3454     GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3455   n->keep_alive_task
3456     = GNUNET_SCHEDULER_add_delayed (sched,
3457                                     GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3458                                     &send_keep_alive,
3459                                     n);
3460   GNUNET_STATISTICS_set (stats,
3461                          gettext_noop ("# bytes of payload decrypted"),
3462                          size - sizeof (struct EncryptedMessage),
3463                          GNUNET_NO);
3464   handle_peer_status_change (n);
3465   if (GNUNET_OK != GNUNET_SERVER_mst_receive (mst,
3466                                               n,
3467                                               &buf[sizeof (struct EncryptedMessage)],
3468                                               size - sizeof (struct EncryptedMessage),
3469                                               GNUNET_YES, GNUNET_NO))
3470     GNUNET_break_op (0);
3471 }
3472
3473
3474 /**
3475  * Function called by the transport for each received message.
3476  *
3477  * @param cls closure
3478  * @param peer (claimed) identity of the other peer
3479  * @param message the message
3480  * @param latency estimated latency for communicating with the
3481  *             given peer (round-trip)
3482  * @param distance in overlay hops, as given by transport plugin
3483  */
3484 static void
3485 handle_transport_receive (void *cls,
3486                           const struct GNUNET_PeerIdentity *peer,
3487                           const struct GNUNET_MessageHeader *message,
3488                           struct GNUNET_TIME_Relative latency,
3489                           unsigned int distance)
3490 {
3491   struct Neighbour *n;
3492   struct GNUNET_TIME_Absolute now;
3493   int up;
3494   uint16_t type;
3495   uint16_t size;
3496   int changed;
3497
3498 #if DEBUG_CORE
3499   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3500               "Received message of type %u from `%4s', demultiplexing.\n",
3501               (unsigned int) ntohs (message->type),
3502               GNUNET_i2s (peer));
3503 #endif
3504   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3505     {
3506       GNUNET_break (0);
3507       return;
3508     }
3509   n = find_neighbour (peer);
3510   if (n == NULL)
3511     n = create_neighbour (peer);
3512   changed = (latency.value != n->last_latency.value) || (distance != n->last_distance);
3513   n->last_latency = latency;
3514   n->last_distance = distance;
3515   up = (n->status == PEER_STATE_KEY_CONFIRMED);
3516   type = ntohs (message->type);
3517   size = ntohs (message->size);
3518   switch (type)
3519     {
3520     case GNUNET_MESSAGE_TYPE_CORE_SET_KEY:
3521       if (size != sizeof (struct SetKeyMessage))
3522         {
3523           GNUNET_break_op (0);
3524           return;
3525         }
3526       GNUNET_STATISTICS_update (stats, gettext_noop ("# session keys received"), 1, GNUNET_NO);
3527       handle_set_key (n, (const struct SetKeyMessage *) message);
3528       break;
3529     case GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE:
3530       if (size < sizeof (struct EncryptedMessage) +
3531           sizeof (struct GNUNET_MessageHeader))
3532         {
3533           GNUNET_break_op (0);
3534           return;
3535         }
3536       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3537           (n->status != PEER_STATE_KEY_CONFIRMED))
3538         {
3539           GNUNET_break_op (0);
3540           return;
3541         }
3542       handle_encrypted_message (n, (const struct EncryptedMessage *) message);
3543       break;
3544     case GNUNET_MESSAGE_TYPE_CORE_PING:
3545       if (size != sizeof (struct PingMessage))
3546         {
3547           GNUNET_break_op (0);
3548           return;
3549         }
3550       GNUNET_STATISTICS_update (stats, gettext_noop ("# PING messages received"), 1, GNUNET_NO);
3551       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3552           (n->status != PEER_STATE_KEY_CONFIRMED))
3553         {
3554 #if DEBUG_CORE
3555           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3556                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3557                       "PING", GNUNET_i2s (&n->peer));
3558 #endif
3559           GNUNET_free_non_null (n->pending_ping);
3560           n->pending_ping = GNUNET_malloc (sizeof (struct PingMessage));
3561           memcpy (n->pending_ping, message, sizeof (struct PingMessage));
3562           return;
3563         }
3564       handle_ping (n, (const struct PingMessage *) message);
3565       break;
3566     case GNUNET_MESSAGE_TYPE_CORE_PONG:
3567       if (size != sizeof (struct PongMessage))
3568         {
3569           GNUNET_break_op (0);
3570           return;
3571         }
3572       GNUNET_STATISTICS_update (stats, gettext_noop ("# PONG messages received"), 1, GNUNET_NO);
3573       if ( (n->status != PEER_STATE_KEY_RECEIVED) &&
3574            (n->status != PEER_STATE_KEY_CONFIRMED) )
3575         {
3576 #if DEBUG_CORE
3577           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3578                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3579                       "PONG", GNUNET_i2s (&n->peer));
3580 #endif
3581           GNUNET_free_non_null (n->pending_pong);
3582           n->pending_pong = GNUNET_malloc (sizeof (struct PongMessage));
3583           memcpy (n->pending_pong, message, sizeof (struct PongMessage));
3584           return;
3585         }
3586       handle_pong (n, (const struct PongMessage *) message);
3587       break;
3588     default:
3589       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3590                   _("Unsupported message of type %u received.\n"),
3591                   (unsigned int) type);
3592       return;
3593     }
3594   if (n->status == PEER_STATE_KEY_CONFIRMED)
3595     {
3596       now = GNUNET_TIME_absolute_get ();
3597       n->last_activity = now;
3598       changed = GNUNET_YES;
3599       if (!up)
3600         {
3601           GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), 1, GNUNET_NO);
3602           n->time_established = now;
3603         }
3604       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3605         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3606       n->keep_alive_task
3607         = GNUNET_SCHEDULER_add_delayed (sched,
3608                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3609                                         &send_keep_alive,
3610                                         n);
3611     }
3612   if (changed)
3613     handle_peer_status_change (n);
3614 }
3615
3616
3617 /**
3618  * Function that recalculates the bandwidth quota for the
3619  * given neighbour and transmits it to the transport service.
3620  *
3621  * @param cls neighbour for the quota update
3622  * @param tc context
3623  */
3624 static void
3625 neighbour_quota_update (void *cls,
3626                         const struct GNUNET_SCHEDULER_TaskContext *tc)
3627 {
3628   struct Neighbour *n = cls;
3629   struct GNUNET_BANDWIDTH_Value32NBO q_in;
3630   double pref_rel;
3631   double share;
3632   unsigned long long distributable;
3633   uint64_t need_per_peer;
3634   uint64_t need_per_second;
3635
3636 #if DEBUG_CORE
3637   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3638               "Neighbour quota update calculation running for peer `%4s'\n",
3639               GNUNET_i2s (&n->peer));
3640 #endif
3641   n->quota_update_task = GNUNET_SCHEDULER_NO_TASK;
3642   /* calculate relative preference among all neighbours;
3643      divides by a bit more to avoid division by zero AND to
3644      account for possibility of new neighbours joining any time
3645      AND to convert to double... */
3646   if (preference_sum == 0)
3647     {
3648       pref_rel = 1.0 / (double) neighbour_count;
3649     }
3650   else
3651     {
3652       pref_rel = n->current_preference / preference_sum;
3653     }
3654   need_per_peer = GNUNET_BANDWIDTH_value_get_available_until (MIN_BANDWIDTH_PER_PEER,
3655                                                               GNUNET_TIME_UNIT_SECONDS);
3656   need_per_second = need_per_peer * neighbour_count;
3657   distributable = 0;
3658   if (bandwidth_target_out_bps > need_per_second)
3659     distributable = bandwidth_target_out_bps - need_per_second;
3660   share = distributable * pref_rel;
3661   if (share + need_per_peer > UINT32_MAX)
3662     q_in = GNUNET_BANDWIDTH_value_init (UINT32_MAX);
3663   else
3664     q_in = GNUNET_BANDWIDTH_value_init (need_per_peer + (uint32_t) share);
3665   /* check if we want to disconnect for good due to inactivity */
3666   if ( (GNUNET_TIME_absolute_get_duration (n->last_activity).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) &&
3667        (GNUNET_TIME_absolute_get_duration (n->time_established).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) )
3668     {
3669 #if DEBUG_CORE
3670       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3671                   "Forcing disconnect of `%4s' due to inactivity\n",
3672                   GNUNET_i2s (&n->peer));
3673 #endif
3674       q_in = GNUNET_BANDWIDTH_value_init (0); /* force disconnect */
3675     }
3676 #if DEBUG_CORE_QUOTA
3677   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3678               "Current quota for `%4s' is %u/%llu b/s in (old: %u b/s) / %u out (%u internal)\n",
3679               GNUNET_i2s (&n->peer),
3680               (unsigned int) ntohl (q_in.value__),
3681               bandwidth_target_out_bps,
3682               (unsigned int) ntohl (n->bw_in.value__),
3683               (unsigned int) ntohl (n->bw_out.value__),
3684               (unsigned int) ntohl (n->bw_out_internal_limit.value__));
3685 #endif
3686   if (n->bw_in.value__ != q_in.value__)
3687     {
3688       n->bw_in = q_in;
3689       if (GNUNET_YES == n->is_connected)
3690         GNUNET_TRANSPORT_set_quota (transport,
3691                                     &n->peer,
3692                                     n->bw_in,
3693                                     n->bw_out,
3694                                     GNUNET_TIME_UNIT_FOREVER_REL,
3695                                     NULL, NULL);
3696       handle_peer_status_change (n);
3697     }
3698   schedule_quota_update (n);
3699 }
3700
3701
3702 /**
3703  * Function called by transport to notify us that
3704  * a peer connected to us (on the network level).
3705  *
3706  * @param cls closure
3707  * @param peer the peer that connected
3708  * @param latency current latency of the connection
3709  * @param distance in overlay hops, as given by transport plugin
3710  */
3711 static void
3712 handle_transport_notify_connect (void *cls,
3713                                  const struct GNUNET_PeerIdentity *peer,
3714                                  struct GNUNET_TIME_Relative latency,
3715                                  unsigned int distance)
3716 {
3717   struct Neighbour *n;
3718
3719   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3720     {
3721       GNUNET_break (0);
3722       return;
3723     }
3724   n = find_neighbour (peer);
3725   if (n != NULL)
3726     {
3727       if (GNUNET_YES == n->is_connected)
3728         {
3729           /* duplicate connect notification!? */
3730           GNUNET_break (0);
3731           return;
3732         }
3733     }
3734   else
3735     {
3736       n = create_neighbour (peer);
3737     }
3738   GNUNET_STATISTICS_update (stats,
3739                             gettext_noop ("# peers connected (transport)"),
3740                             1,
3741                             GNUNET_NO);
3742   n->is_connected = GNUNET_YES;
3743   n->last_latency = latency;
3744   n->last_distance = distance;
3745   GNUNET_BANDWIDTH_tracker_init (&n->available_send_window,
3746                                  n->bw_out,
3747                                  MAX_WINDOW_TIME_S);
3748   GNUNET_BANDWIDTH_tracker_init (&n->available_recv_window,
3749                                  n->bw_in,
3750                                  MAX_WINDOW_TIME_S);
3751 #if DEBUG_CORE
3752   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3753               "Received connection from `%4s'.\n",
3754               GNUNET_i2s (&n->peer));
3755 #endif
3756   GNUNET_TRANSPORT_set_quota (transport,
3757                               &n->peer,
3758                               n->bw_in,
3759                               n->bw_out,
3760                               GNUNET_TIME_UNIT_FOREVER_REL,
3761                               NULL, NULL);
3762   send_key (n);
3763 }
3764
3765
3766 /**
3767  * Function called by transport telling us that a peer
3768  * disconnected.
3769  *
3770  * @param cls closure
3771  * @param peer the peer that disconnected
3772  */
3773 static void
3774 handle_transport_notify_disconnect (void *cls,
3775                                     const struct GNUNET_PeerIdentity *peer)
3776 {
3777   struct DisconnectNotifyMessage cnm;
3778   struct Neighbour *n;
3779   struct GNUNET_TIME_Relative left;
3780
3781 #if DEBUG_CORE
3782   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3783               "Peer `%4s' disconnected from us; received notification from transport.\n", GNUNET_i2s (peer));
3784 #endif
3785
3786   n = find_neighbour (peer);
3787   if (n == NULL)
3788     {
3789       GNUNET_break (0);
3790       return;
3791     }
3792   GNUNET_break (n->is_connected);
3793   if (n->status == PEER_STATE_KEY_CONFIRMED)
3794     {
3795       cnm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
3796       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
3797       cnm.peer = *peer;
3798       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_DISCONNECT);
3799     }
3800   n->is_connected = GNUNET_NO;
3801   GNUNET_STATISTICS_update (stats,
3802                             gettext_noop ("# peers connected (transport)"),
3803                             -1,
3804                             GNUNET_NO);
3805   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
3806     GNUNET_SCHEDULER_cancel (sched,
3807                              n->dead_clean_task);
3808   left = GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
3809                                         GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
3810   n->last_activity = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (),
3811                                                     left);
3812   n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
3813                                                      GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
3814                                                      &consider_free_task,
3815                                                      n);
3816 }
3817
3818
3819 /**
3820  * Last task run during shutdown.  Disconnects us from
3821  * the transport.
3822  */
3823 static void
3824 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
3825 {
3826   struct Neighbour *n;
3827   struct Client *c;
3828
3829 #if DEBUG_CORE
3830   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3831               "Core service shutting down.\n");
3832 #endif
3833   GNUNET_assert (transport != NULL);
3834   GNUNET_TRANSPORT_disconnect (transport);
3835   transport = NULL;
3836   while (NULL != (n = neighbours))
3837     {
3838       neighbours = n->next;
3839       GNUNET_assert (neighbour_count > 0);
3840       neighbour_count--;
3841       free_neighbour (n);
3842     }
3843   GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), neighbour_count, GNUNET_NO);
3844   GNUNET_SERVER_notification_context_destroy (notifier);
3845   notifier = NULL;
3846   while (NULL != (c = clients))
3847     handle_client_disconnect (NULL, c->client_handle);
3848   if (my_private_key != NULL)
3849     GNUNET_CRYPTO_rsa_key_free (my_private_key);
3850   if (stats != NULL)
3851     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
3852   if (peerinfo != NULL)
3853     GNUNET_PEERINFO_disconnect (peerinfo);
3854   if (mst != NULL)
3855     GNUNET_SERVER_mst_destroy (mst);
3856 }
3857
3858
3859 /**
3860  * Initiate core service.
3861  *
3862  * @param cls closure
3863  * @param s scheduler to use
3864  * @param server the initialized server
3865  * @param c configuration to use
3866  */
3867 static void
3868 run (void *cls,
3869      struct GNUNET_SCHEDULER_Handle *s,
3870      struct GNUNET_SERVER_Handle *server,
3871      const struct GNUNET_CONFIGURATION_Handle *c)
3872 {
3873   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
3874     {&handle_client_init, NULL,
3875      GNUNET_MESSAGE_TYPE_CORE_INIT, 0},
3876     {&handle_client_request_info, NULL,
3877      GNUNET_MESSAGE_TYPE_CORE_REQUEST_INFO,
3878      sizeof (struct RequestInfoMessage)},
3879     {&handle_client_iterate_peers, NULL,
3880      GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS,
3881      sizeof (struct GNUNET_MessageHeader)},
3882     {&handle_client_send, NULL,
3883      GNUNET_MESSAGE_TYPE_CORE_SEND, 0},
3884     {&handle_client_request_connect, NULL,
3885      GNUNET_MESSAGE_TYPE_CORE_REQUEST_CONNECT,
3886      sizeof (struct ConnectMessage)},
3887     {NULL, NULL, 0, 0}
3888   };
3889   char *keyfile;
3890
3891   sched = s;
3892   cfg = c;
3893   /* parse configuration */
3894   if (
3895        (GNUNET_OK !=
3896         GNUNET_CONFIGURATION_get_value_number (c,
3897                                                "CORE",
3898                                                "TOTAL_QUOTA_IN",
3899                                                &bandwidth_target_in_bps)) ||
3900        (GNUNET_OK !=
3901         GNUNET_CONFIGURATION_get_value_number (c,
3902                                                "CORE",
3903                                                "TOTAL_QUOTA_OUT",
3904                                                &bandwidth_target_out_bps)) ||
3905        (GNUNET_OK !=
3906         GNUNET_CONFIGURATION_get_value_filename (c,
3907                                                  "GNUNETD",
3908                                                  "HOSTKEY", &keyfile)))
3909     {
3910       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3911                   _
3912                   ("Core service is lacking key configuration settings.  Exiting.\n"));
3913       GNUNET_SCHEDULER_shutdown (s);
3914       return;
3915     }
3916   peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
3917   if (NULL == peerinfo)
3918     {
3919       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3920                   _("Could not access PEERINFO service.  Exiting.\n"));
3921       GNUNET_SCHEDULER_shutdown (s);
3922       GNUNET_free (keyfile);
3923       return;
3924     }
3925   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
3926   GNUNET_free (keyfile);
3927   if (my_private_key == NULL)
3928     {
3929       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3930                   _("Core service could not access hostkey.  Exiting.\n"));
3931       GNUNET_PEERINFO_disconnect (peerinfo);
3932       GNUNET_SCHEDULER_shutdown (s);
3933       return;
3934     }
3935   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
3936   GNUNET_CRYPTO_hash (&my_public_key,
3937                       sizeof (my_public_key), &my_identity.hashPubKey);
3938   /* setup notification */
3939   notifier = GNUNET_SERVER_notification_context_create (server,
3940                                                         MAX_NOTIFY_QUEUE);
3941   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
3942   /* setup transport connection */
3943   transport = GNUNET_TRANSPORT_connect (sched,
3944                                         cfg,
3945                                         &my_identity,
3946                                         NULL,
3947                                         &handle_transport_receive,
3948                                         &handle_transport_notify_connect,
3949                                         &handle_transport_notify_disconnect);
3950   GNUNET_assert (NULL != transport);
3951   stats = GNUNET_STATISTICS_create (sched, "core", cfg);
3952   mst = GNUNET_SERVER_mst_create (&deliver_message,
3953                                   NULL);
3954   GNUNET_SCHEDULER_add_delayed (sched,
3955                                 GNUNET_TIME_UNIT_FOREVER_REL,
3956                                 &cleaning_task, NULL);
3957   /* process client requests */
3958   GNUNET_SERVER_add_handlers (server, handlers);
3959   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3960               _("Core service of `%4s' ready.\n"), GNUNET_i2s (&my_identity));
3961 }
3962
3963
3964
3965 /**
3966  * The main function for the transport service.
3967  *
3968  * @param argc number of arguments from the command line
3969  * @param argv command line arguments
3970  * @return 0 ok, 1 on error
3971  */
3972 int
3973 main (int argc, char *const *argv)
3974 {
3975   return (GNUNET_OK ==
3976           GNUNET_SERVICE_run (argc,
3977                               argv,
3978                               "core",
3979                               GNUNET_SERVICE_OPTION_NONE,
3980                               &run, NULL)) ? 0 : 1;
3981 }
3982
3983 /* end of gnunet-service-core.c */