src/core/gnunet-service-core.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file core/gnunet-service-core.c
  23  * @brief high-level P2P messaging
  24  * @author Christian Grothoff
  25  *
  26  * Considerations for later:
  27  * - check that hostkey used by transport (for HELLOs) is the
  28  *   same as the hostkey that we are using!
  29  * - add code to send PINGs if we are about to time-out otherwise
  30  * - optimize lookup (many O(n) list traversals
  31  *   could ideally be changed to O(1) hash map lookups)
  32  */
  33 #include "platform.h"
  34 #include "gnunet_constants.h"
  35 #include "gnunet_util_lib.h"
  36 #include "gnunet_hello_lib.h"
  37 #include "gnunet_peerinfo_service.h"
  38 #include "gnunet_protocols.h"
  39 #include "gnunet_signatures.h"
  40 #include "gnunet_statistics_service.h"
  41 #include "gnunet_transport_service.h"
  42 #include "core.h"
  43
  44
  45 #define DEBUG_HANDSHAKE GNUNET_NO
  46
  47 #define DEBUG_CORE_QUOTA GNUNET_NO
  48
  49 /**
  50  * Receive and send buffer windows grow over time.  For
  51  * how long can 'unused' bandwidth accumulate before we
  52  * need to cap it?  (specified in seconds).
  53  */
  54 #define MAX_WINDOW_TIME_S (5 * 60)
  55
  56 /**
  57  * How many messages do we queue up at most for optional
  58  * notifications to a client?  (this can cause notifications
  59  * about outgoing messages to be dropped).
  60  */
  61 #define MAX_NOTIFY_QUEUE 1024
  62
  63 /**
  64  * Minimum bandwidth (out) to assign to any connected peer.
  65  * Should be rather low; values larger than DEFAULT_BW_IN_OUT make no
  66  * sense.
  67  */
  68 #define MIN_BANDWIDTH_PER_PEER GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT
  69
  70 /**
  71  * After how much time past the "official" expiration time do
  72  * we discard messages?  Should not be zero since we may
  73  * intentionally defer transmission until close to the deadline
  74  * and then may be slightly past the deadline due to inaccuracy
  75  * in sleep and our own CPU consumption.
  76  */
  77 #define PAST_EXPIRATION_DISCARD_TIME GNUNET_TIME_UNIT_SECONDS
  78
  79 /**
  80  * What is the maximum delay for a SET_KEY message?
  81  */
  82 #define MAX_SET_KEY_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
  83
  84 /**
  85  * How long do we wait for SET_KEY confirmation initially?
  86  */
  87 #define INITIAL_SET_KEY_RETRY_FREQUENCY GNUNET_TIME_relative_multiply (MAX_SET_KEY_DELAY, 1)
  88
  89 /**
  90  * What is the maximum delay for a PING message?
  91  */
  92 #define MAX_PING_DELAY GNUNET_TIME_relative_multiply (MAX_SET_KEY_DELAY, 2)
  93
  94 /**
  95  * What is the maximum delay for a PONG message?
  96  */
  97 #define MAX_PONG_DELAY GNUNET_TIME_relative_multiply (MAX_PING_DELAY, 2)
  98
  99 /**
 100  * What is the minimum frequency for a PING message?
 101  */
 102 #define MIN_PING_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 103
 104 /**
 105  * How often do we recalculate bandwidth quotas?
 106  */
 107 #define QUOTA_UPDATE_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 108
 109 /**
 110  * What is the priority for a SET_KEY message?
 111  */
 112 #define SET_KEY_PRIORITY 0xFFFFFF
 113
 114 /**
 115  * What is the priority for a PING message?
 116  */
 117 #define PING_PRIORITY 0xFFFFFF
 118
 119 /**
 120  * What is the priority for a PONG message?
 121  */
 122 #define PONG_PRIORITY 0xFFFFFF
 123
 124 /**
 125  * How many messages do we queue per peer at most?  Must be at
 126  * least two.
 127  */
 128 #define MAX_PEER_QUEUE_SIZE 16
 129
 130 /**
 131  * How many non-mandatory messages do we queue per client at most?
 132  */
 133 #define MAX_CLIENT_QUEUE_SIZE 32
 134
 135 /**
 136  * What is the maximum age of a message for us to consider
 137  * processing it?  Note that this looks at the timestamp used
 138  * by the other peer, so clock skew between machines does
 139  * come into play here.  So this should be picked high enough
 140  * so that a little bit of clock skew does not prevent peers
 141  * from connecting to us.
 142  */
 143 #define MAX_MESSAGE_AGE GNUNET_TIME_UNIT_DAYS
 144
 145
 146 /**
 147  * State machine for our P2P encryption handshake.  Everyone starts in
 148  * "DOWN", if we receive the other peer's key (other peer initiated)
 149  * we start in state RECEIVED (since we will immediately send our
 150  * own); otherwise we start in SENT.  If we get back a PONG from
 151  * within either state, we move up to CONFIRMED (the PONG will always
 152  * be sent back encrypted with the key we sent to the other peer).
 153  */
 154 enum PeerStateMachine
 155 {
 156   PEER_STATE_DOWN,
 157   PEER_STATE_KEY_SENT,
 158   PEER_STATE_KEY_RECEIVED,
 159   PEER_STATE_KEY_CONFIRMED
 160 };
 161
 162
 163 /**
 164  * Number of bytes (at the beginning) of "struct EncryptedMessage"
 165  * that are NOT encrypted.
 166  */
 167 #define ENCRYPTED_HEADER_SIZE (sizeof(struct GNUNET_MessageHeader) + sizeof(uint32_t))
 168
 169
 170 /**
 171  * Encapsulation for encrypted messages exchanged between
 172  * peers.  Followed by the actual encrypted data.
 173  */
 174 struct EncryptedMessage
 175 {
 176   /**
 177    * Message type is either CORE_ENCRYPTED_MESSAGE.
 178    */
 179   struct GNUNET_MessageHeader header;
 180
 181   /**
 182    * Random value used for IV generation.  ENCRYPTED_HEADER_SIZE must
 183    * be set to the offset of the *next* field.
 184    */
 185   uint32_t iv_seed GNUNET_PACKED;
 186
 187   /**
 188    * Hash of the plaintext (starting at 'sequence_number'), used to
 189    * verify message integrity.  Everything after this hash (including
 190    * this hash itself) will be encrypted.
 191    */
 192   GNUNET_HashCode hmac;
 193
 194   /**
 195    * Sequence number, in network byte order.  This field
 196    * must be the first encrypted/decrypted field and the
 197    * first byte that is hashed for the plaintext hash.
 198    */
 199   uint32_t sequence_number GNUNET_PACKED;
 200
 201   /**
 202    * Desired bandwidth (how much we should send to this peer / how
 203    * much is the sender willing to receive)?
 204    */
 205   struct GNUNET_BANDWIDTH_Value32NBO inbound_bw_limit;
 206
 207   /**
 208    * Timestamp.  Used to prevent reply of ancient messages
 209    * (recent messages are caught with the sequence number).
 210    */
 211   struct GNUNET_TIME_AbsoluteNBO timestamp;
 212
 213 };
 214
 215
 216 /**
 217  * We're sending an (encrypted) PING to the other peer to check if he
 218  * can decrypt.  The other peer should respond with a PONG with the
 219  * same content, except this time encrypted with the receiver's key.
 220  */
 221 struct PingMessage
 222 {
 223   /**
 224    * Message type is CORE_PING.
 225    */
 226   struct GNUNET_MessageHeader header;
 227
 228   /**
 229    * Random number chosen to make reply harder.
 230    */
 231   uint32_t challenge GNUNET_PACKED;
 232
 233   /**
 234    * Intended target of the PING, used primarily to check
 235    * that decryption actually worked.
 236    */
 237   struct GNUNET_PeerIdentity target;
 238 };
 239
 240
 241
 242 /**
 243  * Response to a PING.  Includes data from the original PING
 244  * plus initial bandwidth quota information.
 245  */
 246 struct PongMessage
 247 {
 248   /**
 249    * Message type is CORE_PONG.
 250    */
 251   struct GNUNET_MessageHeader header;
 252
 253   /**
 254    * Random number proochosen to make reply harder.  Must be
 255    * first field after header (this is where we start to encrypt!).
 256    */
 257   uint32_t challenge GNUNET_PACKED;
 258
 259   /**
 260    * Must be zero.
 261    */
 262   uint32_t reserved GNUNET_PACKED;
 263
 264   /**
 265    * Desired bandwidth (how much we should send to this
 266    * peer / how much is the sender willing to receive).
 267    */
 268   struct GNUNET_BANDWIDTH_Value32NBO inbound_bw_limit;
 269
 270   /**
 271    * Intended target of the PING, used primarily to check
 272    * that decryption actually worked.
 273    */
 274   struct GNUNET_PeerIdentity target;
 275 };
 276
 277
 278 /**
 279  * Message transmitted to set (or update) a session key.
 280  */
 281 struct SetKeyMessage
 282 {
 283
 284   /**
 285    * Message type is either CORE_SET_KEY.
 286    */
 287   struct GNUNET_MessageHeader header;
 288
 289   /**
 290    * Status of the sender (should be in "enum PeerStateMachine"), nbo.
 291    */
 292   int32_t sender_status GNUNET_PACKED;
 293
 294   /**
 295    * Purpose of the signature, will be
 296    * GNUNET_SIGNATURE_PURPOSE_SET_KEY.
 297    */
 298   struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
 299
 300   /**
 301    * At what time was this key created?
 302    */
 303   struct GNUNET_TIME_AbsoluteNBO creation_time;
 304
 305   /**
 306    * The encrypted session key.
 307    */
 308   struct GNUNET_CRYPTO_RsaEncryptedData encrypted_key;
 309
 310   /**
 311    * Who is the intended recipient?
 312    */
 313   struct GNUNET_PeerIdentity target;
 314
 315   /**
 316    * Signature of the stuff above (starting at purpose).
 317    */
 318   struct GNUNET_CRYPTO_RsaSignature signature;
 319
 320 };
 321
 322
 323 /**
 324  * Message waiting for transmission. This struct
 325  * is followed by the actual content of the message.
 326  */
 327 struct MessageEntry
 328 {
 329
 330   /**
 331    * We keep messages in a doubly linked list.
 332    */
 333   struct MessageEntry *next;
 334
 335   /**
 336    * We keep messages in a doubly linked list.
 337    */
 338   struct MessageEntry *prev;
 339
 340   /**
 341    * By when are we supposed to transmit this message?
 342    */
 343   struct GNUNET_TIME_Absolute deadline;
 344
 345   /**
 346    * By when are we supposed to transmit this message (after
 347    * giving slack)?
 348    */
 349   struct GNUNET_TIME_Absolute slack_deadline;
 350
 351   /**
 352    * How important is this message to us?
 353    */
 354   unsigned int priority;
 355
 356   /**
 357    * If this is a SET_KEY message, what was our connection status when this
 358    * message was queued?
 359    */
 360   enum PeerStateMachine sender_status;
 361
 362   /**
 363    * Is this a SET_KEY message?
 364    */
 365   int is_setkey;
 366
 367   /**
 368    * How long is the message? (number of bytes following
 369    * the "struct MessageEntry", but not including the
 370    * size of "struct MessageEntry" itself!)
 371    */
 372   uint16_t size;
 373
 374   /**
 375    * Was this message selected for transmission in the
 376    * current round? GNUNET_YES or GNUNET_NO.
 377    */
 378   int8_t do_transmit;
 379
 380   /**
 381    * Did we give this message some slack (delayed sending) previously
 382    * (and hence should not give it any more slack)? GNUNET_YES or
 383    * GNUNET_NO.
 384    */
 385   int8_t got_slack;
 386
 387 };
 388
 389
 390 struct Neighbour
 391 {
 392   /**
 393    * We keep neighbours in a linked list (for now).
 394    */
 395   struct Neighbour *next;
 396
 397   /**
 398    * Unencrypted messages destined for this peer.
 399    */
 400   struct MessageEntry *messages;
 401
 402   /**
 403    * Head of the batched, encrypted message queue (already ordered,
 404    * transmit starting with the head).
 405    */
 406   struct MessageEntry *encrypted_head;
 407
 408   /**
 409    * Tail of the batched, encrypted message queue (already ordered,
 410    * append new messages to tail)
 411    */
 412   struct MessageEntry *encrypted_tail;
 413
 414   /**
 415    * Handle for pending requests for transmission to this peer
 416    * with the transport service.  NULL if no request is pending.
 417    */
 418   struct GNUNET_TRANSPORT_TransmitHandle *th;
 419
 420   /**
 421    * Public key of the neighbour, NULL if we don't have it yet.
 422    */
 423   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key;
 424
 425   /**
 426    * We received a PING message before we got the "public_key"
 427    * (or the SET_KEY).  We keep it here until we have a key
 428    * to decrypt it.  NULL if no PING is pending.
 429    */
 430   struct PingMessage *pending_ping;
 431
 432   /**
 433    * We received a PONG message before we got the "public_key"
 434    * (or the SET_KEY).  We keep it here until we have a key
 435    * to decrypt it.  NULL if no PONG is pending.
 436    */
 437   struct PongMessage *pending_pong;
 438
 439   /**
 440    * Non-NULL if we are currently looking up HELLOs for this peer.
 441    * for this peer.
 442    */
 443   struct GNUNET_PEERINFO_IteratorContext *pitr;
 444
 445   /**
 446    * SetKeyMessage to transmit, NULL if we are not currently trying
 447    * to send one.
 448    */
 449   struct SetKeyMessage *skm;
 450
 451   /**
 452    * Identity of the neighbour.
 453    */
 454   struct GNUNET_PeerIdentity peer;
 455
 456   /**
 457    * Key we use to encrypt our messages for the other peer
 458    * (initialized by us when we do the handshake).
 459    */
 460   struct GNUNET_CRYPTO_AesSessionKey encrypt_key;
 461
 462   /**
 463    * Key we use to decrypt messages from the other peer
 464    * (given to us by the other peer during the handshake).
 465    */
 466   struct GNUNET_CRYPTO_AesSessionKey decrypt_key;
 467
 468   /**
 469    * ID of task used for re-trying plaintext scheduling.
 470    */
 471   GNUNET_SCHEDULER_TaskIdentifier retry_plaintext_task;
 472
 473   /**
 474    * ID of task used for re-trying SET_KEY and PING message.
 475    */
 476   GNUNET_SCHEDULER_TaskIdentifier retry_set_key_task;
 477
 478   /**
 479    * ID of task used for updating bandwidth quota for this neighbour.
 480    */
 481   GNUNET_SCHEDULER_TaskIdentifier quota_update_task;
 482
 483   /**
 484    * ID of task used for sending keep-alive pings.
 485    */
 486   GNUNET_SCHEDULER_TaskIdentifier keep_alive_task;
 487
 488   /**
 489    * ID of task used for cleaning up dead neighbour entries.
 490    */
 491   GNUNET_SCHEDULER_TaskIdentifier dead_clean_task;
 492
 493   /**
 494    * At what time did we generate our encryption key?
 495    */
 496   struct GNUNET_TIME_Absolute encrypt_key_created;
 497
 498   /**
 499    * At what time did the other peer generate the decryption key?
 500    */
 501   struct GNUNET_TIME_Absolute decrypt_key_created;
 502
 503   /**
 504    * At what time did we initially establish (as in, complete session
 505    * key handshake) this connection?  Should be zero if status != KEY_CONFIRMED.
 506    */
 507   struct GNUNET_TIME_Absolute time_established;
 508
 509   /**
 510    * At what time did we last receive an encrypted message from the
 511    * other peer?  Should be zero if status != KEY_CONFIRMED.
 512    */
 513   struct GNUNET_TIME_Absolute last_activity;
 514
 515   /**
 516    * Last latency observed from this peer.
 517    */
 518   struct GNUNET_TIME_Relative last_latency;
 519
 520   /**
 521    * At what frequency are we currently re-trying SET_KEY messages?
 522    */
 523   struct GNUNET_TIME_Relative set_key_retry_frequency;
 524
 525   /**
 526    * Tracking bandwidth for sending to this peer.
 527    */
 528   struct GNUNET_BANDWIDTH_Tracker available_send_window;
 529
 530   /**
 531    * Tracking bandwidth for receiving from this peer.
 532    */
 533   struct GNUNET_BANDWIDTH_Tracker available_recv_window;
 534
 535   /**
 536    * How valueable were the messages of this peer recently?
 537    */
 538   unsigned long long current_preference;
 539
 540   /**
 541    * Bit map indicating which of the 32 sequence numbers before the last
 542    * were received (good for accepting out-of-order packets and
 543    * estimating reliability of the connection)
 544    */
 545   unsigned int last_packets_bitmap;
 546
 547   /**
 548    * last sequence number received on this connection (highest)
 549    */
 550   uint32_t last_sequence_number_received;
 551
 552   /**
 553    * last sequence number transmitted
 554    */
 555   uint32_t last_sequence_number_sent;
 556
 557   /**
 558    * Available bandwidth in for this peer (current target).
 559    */
 560   struct GNUNET_BANDWIDTH_Value32NBO bw_in;
 561
 562   /**
 563    * Available bandwidth out for this peer (current target).
 564    */
 565   struct GNUNET_BANDWIDTH_Value32NBO bw_out;
 566
 567   /**
 568    * Internal bandwidth limit set for this peer (initially typically
 569    * set to "-1").  Actual "bw_out" is MIN of
 570    * "bpm_out_internal_limit" and "bw_out_external_limit".
 571    */
 572   struct GNUNET_BANDWIDTH_Value32NBO bw_out_internal_limit;
 573
 574   /**
 575    * External bandwidth limit set for this peer by the
 576    * peer that we are communicating with.  "bw_out" is MIN of
 577    * "bw_out_internal_limit" and "bw_out_external_limit".
 578    */
 579   struct GNUNET_BANDWIDTH_Value32NBO bw_out_external_limit;
 580
 581   /**
 582    * What was our PING challenge number (for this peer)?
 583    */
 584   uint32_t ping_challenge;
 585
 586   /**
 587    * What was the last distance to this peer as reported by the transports?
 588    */
 589   uint32_t last_distance;
 590
 591   /**
 592    * What is our connection status?
 593    */
 594   enum PeerStateMachine status;
 595
 596   /**
 597    * Are we currently connected to this neighbour?
 598    */
 599   int is_connected;
 600
 601 };
 602
 603
 604 /**
 605  * Data structure for each client connected to the core service.
 606  */
 607 struct Client
 608 {
 609   /**
 610    * Clients are kept in a linked list.
 611    */
 612   struct Client *next;
 613
 614   /**
 615    * Handle for the client with the server API.
 616    */
 617   struct GNUNET_SERVER_Client *client_handle;
 618
 619   /**
 620    * Array of the types of messages this peer cares
 621    * about (with "tcnt" entries).  Allocated as part
 622    * of this client struct, do not free!
 623    */
 624   const uint16_t *types;
 625
 626   /**
 627    * Options for messages this client cares about,
 628    * see GNUNET_CORE_OPTION_ values.
 629    */
 630   uint32_t options;
 631
 632   /**
 633    * Number of types of incoming messages this client
 634    * specifically cares about.  Size of the "types" array.
 635    */
 636   unsigned int tcnt;
 637
 638 };
 639
 640
 641 /**
 642  * Our public key.
 643  */
 644 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
 645
 646 /**
 647  * Our identity.
 648  */
 649 static struct GNUNET_PeerIdentity my_identity;
 650
 651 /**
 652  * Our private key.
 653  */
 654 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
 655
 656 /**
 657  * Our scheduler.
 658  */
 659 struct GNUNET_SCHEDULER_Handle *sched;
 660
 661 /**
 662  * Handle to peerinfo service.
 663  */
 664 static struct GNUNET_PEERINFO_Handle *peerinfo;
 665
 666 /**
 667  * Our message stream tokenizer (for encrypted payload).
 668  */
 669 static struct GNUNET_SERVER_MessageStreamTokenizer *mst;
 670
 671 /**
 672  * Our configuration.
 673  */
 674 const struct GNUNET_CONFIGURATION_Handle *cfg;
 675
 676 /**
 677  * Transport service.
 678  */
 679 static struct GNUNET_TRANSPORT_Handle *transport;
 680
 681 /**
 682  * Linked list of our clients.
 683  */
 684 static struct Client *clients;
 685
 686 /**
 687  * Context for notifications we need to send to our clients.
 688  */
 689 static struct GNUNET_SERVER_NotificationContext *notifier;
 690
 691 /**
 692  * We keep neighbours in a linked list (for now).
 693  */
 694 static struct Neighbour *neighbours;
 695
 696 /**
 697  * For creating statistics.
 698  */
 699 static struct GNUNET_STATISTICS_Handle *stats;
 700
 701 /**
 702  * Sum of all preferences among all neighbours.
 703  */
 704 static unsigned long long preference_sum;
 705
 706 /**
 707  * Total number of neighbours we have.
 708  */
 709 static unsigned int neighbour_count;
 710
 711 /**
 712  * How much inbound bandwidth are we supposed to be using per second?
 713  * FIXME: this value is not used!
 714  */
 715 static unsigned long long bandwidth_target_in_bps;
 716
 717 /**
 718  * How much outbound bandwidth are we supposed to be using per second?
 719  */
 720 static unsigned long long bandwidth_target_out_bps;
 721
 722
 723
 724 /**
 725  * A preference value for a neighbour was update.  Update
 726  * the preference sum accordingly.
 727  *
 728  * @param inc how much was a preference value increased?
 729  */
 730 static void
 731 update_preference_sum (unsigned long long inc)
 732 {
 733   struct Neighbour *n;
 734   unsigned long long os;
 735
 736   os = preference_sum;
 737   preference_sum += inc;
 738   if (preference_sum >= os)
 739     return; /* done! */
 740   /* overflow! compensate by cutting all values in half! */
 741   preference_sum = 0;
 742   n = neighbours;
 743   while (n != NULL)
 744     {
 745       n->current_preference /= 2;
 746       preference_sum += n->current_preference;
 747       n = n->next;
 748     }
 749   GNUNET_STATISTICS_set (stats, gettext_noop ("# total peer preference"), preference_sum, GNUNET_NO);
 750 }
 751
 752
 753 /**
 754  * Find the entry for the given neighbour.
 755  *
 756  * @param peer identity of the neighbour
 757  * @return NULL if we are not connected, otherwise the
 758  *         neighbour's entry.
 759  */
 760 static struct Neighbour *
 761 find_neighbour (const struct GNUNET_PeerIdentity *peer)
 762 {
 763   struct Neighbour *ret;
 764
 765   ret = neighbours;
 766   while ((ret != NULL) &&
 767          (0 != memcmp (&ret->peer,
 768                        peer, sizeof (struct GNUNET_PeerIdentity))))
 769     ret = ret->next;
 770   return ret;
 771 }
 772
 773
 774 /**
 775  * Send a message to one of our clients.
 776  *
 777  * @param client target for the message
 778  * @param msg message to transmit
 779  * @param can_drop could this message be dropped if the
 780  *        client's queue is getting too large?
 781  */
 782 static void
 783 send_to_client (struct Client *client,
 784                 const struct GNUNET_MessageHeader *msg,
 785                 int can_drop)
 786 {
 787 #if DEBUG_CORE_CLIENT
 788   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 789               "Preparing to send %u bytes of message of type %u to client.\n",
 790               (unsigned int) ntohs (msg->size),
 791               (unsigned int) ntohs (msg->type));
 792 #endif
 793   GNUNET_SERVER_notification_context_unicast (notifier,
 794                                               client->client_handle,
 795                                               msg,
 796                                               can_drop);
 797 }
 798
 799
 800 /**
 801  * Send a message to all of our current clients that have
 802  * the right options set.
 803  *
 804  * @param msg message to multicast
 805  * @param can_drop can this message be discarded if the queue is too long
 806  * @param options mask to use
 807  */
 808 static void
 809 send_to_all_clients (const struct GNUNET_MessageHeader *msg,
 810                      int can_drop,
 811                      int options)
 812 {
 813   struct Client *c;
 814
 815   c = clients;
 816   while (c != NULL)
 817     {
 818       if (0 != (c->options & options))
 819         {
 820 #if DEBUG_CORE_CLIENT
 821           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 822                       "Sending message of type %u to client.\n",
 823                       (unsigned int) ntohs (msg->type));
 824 #endif
 825           send_to_client (c, msg, can_drop);
 826         }
 827       c = c->next;
 828     }
 829 }
 830
 831
 832 /**
 833  * Function called by transport telling us that a peer
 834  * changed status.
 835  *
 836  * @param 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       GNUNET_break (0);
2376       return 0;
2377     }
2378   n->th = NULL;
2379   if (buf == NULL)
2380     {
2381       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2382                   _("Failed to connect to `%4s': transport failed to connect\n"),
2383                   GNUNET_i2s (&n->peer));
2384       return 0;
2385     }
2386   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2387               _("TRANSPORT connection to peer `%4s' is up, trying to establish CORE connection\n"),
2388               GNUNET_i2s (&n->peer));
2389   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2390     GNUNET_SCHEDULER_cancel (sched,
2391                              n->retry_set_key_task);
2392   n->retry_set_key_task = GNUNET_SCHEDULER_add_now (sched,
2393                                                     &set_key_retry_task,
2394                                                     n);
2395   return 0;
2396 }
2397
2398
2399 /**
2400  * Handle CORE_REQUEST_CONNECT request.
2401  *
2402  * @param cls unused
2403  * @param client the client issuing the request
2404  * @param message the "struct ConnectMessage"
2405  */
2406 static void
2407 handle_client_request_connect (void *cls,
2408                                struct GNUNET_SERVER_Client *client,
2409                                const struct GNUNET_MessageHeader *message)
2410 {
2411   const struct ConnectMessage *cm = (const struct ConnectMessage*) message;
2412   struct Neighbour *n;
2413   struct GNUNET_TIME_Relative timeout;
2414
2415   if (0 == memcmp (&cm->peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2416     {
2417       GNUNET_break (0);
2418       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
2419       return;
2420     }
2421   GNUNET_SERVER_receive_done (client, GNUNET_OK);
2422   n = find_neighbour (&cm->peer);
2423   if (n == NULL)
2424     n = create_neighbour (&cm->peer);
2425   if ( (GNUNET_YES == n->is_connected) ||
2426        (n->th != NULL) )
2427     {
2428       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2429                  "Core received `%s' request for `%4s', already connected!\n",
2430                  "REQUEST_CONNECT",
2431                  GNUNET_i2s (&cm->peer));
2432       return; /* already connected, or at least trying */
2433     }
2434   GNUNET_STATISTICS_update (stats, gettext_noop ("# connection requests received"), 1, GNUNET_NO);
2435
2436   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2437               "Core received `%s' request for `%4s', will try to establish connection\n",
2438               "REQUEST_CONNECT",
2439               GNUNET_i2s (&cm->peer));
2440
2441   timeout = GNUNET_TIME_relative_ntoh (cm->timeout);
2442   /* ask transport to connect to the peer */
2443   n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2444                                                   &cm->peer,
2445                                                   sizeof (struct GNUNET_MessageHeader), 0,
2446                                                   timeout,
2447                                                   &notify_transport_connect_done,
2448                                                   n);
2449   GNUNET_break (NULL != n->th);
2450 }
2451
2452
2453 /**
2454  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2455  * the neighbour's struct and retry send_key.  Or, if we did not get a
2456  * HELLO, just do nothing.
2457  *
2458  * @param cls the 'struct Neighbour' to retry sending the key for
2459  * @param peer the peer for which this is the HELLO
2460  * @param hello HELLO message of that peer
2461  */
2462 static void
2463 process_hello_retry_send_key (void *cls,
2464                               const struct GNUNET_PeerIdentity *peer,
2465                               const struct GNUNET_HELLO_Message *hello)
2466 {
2467   struct Neighbour *n = cls;
2468
2469   if (peer == NULL)
2470     {
2471 #if DEBUG_CORE
2472       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2473                   "Entered `%s' and `%s' is NULL!\n",
2474                   "process_hello_retry_send_key",
2475                   "peer");
2476 #endif
2477       n->pitr = NULL;
2478       if (n->public_key != NULL)
2479         {
2480           if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2481             {
2482               GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2483               n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2484             }
2485           GNUNET_STATISTICS_update (stats,
2486                                     gettext_noop ("# SET_KEY messages deferred (need public key)"),
2487                                     -1,
2488                                     GNUNET_NO);
2489           send_key (n);
2490         }
2491       else
2492         {
2493 #if DEBUG_CORE
2494           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2495                       "Failed to obtain public key for peer `%4s', delaying processing of SET_KEY\n",
2496                       GNUNET_i2s (&n->peer));
2497 #endif
2498           GNUNET_STATISTICS_update (stats,
2499                                     gettext_noop ("# Delayed connecting due to lack of public key"),
2500                                     1,
2501                                     GNUNET_NO);
2502           if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
2503             n->retry_set_key_task
2504               = GNUNET_SCHEDULER_add_delayed (sched,
2505                                               n->set_key_retry_frequency,
2506                                               &set_key_retry_task, n);
2507         }
2508       return;
2509     }
2510
2511 #if DEBUG_CORE
2512   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2513               "Entered `%s' for peer `%4s'\n",
2514               "process_hello_retry_send_key",
2515               GNUNET_i2s (peer));
2516 #endif
2517   if (n->public_key != NULL)
2518     {
2519       /* already have public key, why are we here? */
2520       GNUNET_break (0);
2521       return;
2522     }
2523
2524 #if DEBUG_CORE
2525   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2526               "Received new `%s' message for `%4s', initiating key exchange.\n",
2527               "HELLO",
2528               GNUNET_i2s (peer));
2529 #endif
2530   n->public_key =
2531     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2532   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2533     {
2534       GNUNET_STATISTICS_update (stats,
2535                                 gettext_noop ("# Error extracting public key from HELLO"),
2536                                 1,
2537                                 GNUNET_NO);
2538       GNUNET_free (n->public_key);
2539       n->public_key = NULL;
2540 #if DEBUG_CORE
2541   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2542               "GNUNET_HELLO_get_key returned awfully\n");
2543 #endif
2544       return;
2545     }
2546 }
2547
2548
2549 /**
2550  * Send our key (and encrypted PING) to the other peer.
2551  *
2552  * @param n the other peer
2553  */
2554 static void
2555 send_key (struct Neighbour *n)
2556 {
2557   struct MessageEntry *pos;
2558   struct SetKeyMessage *sm;
2559   struct MessageEntry *me;
2560   struct PingMessage pp;
2561   struct PingMessage *pm;
2562
2563   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2564     {
2565       GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
2566       n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
2567     }
2568   if (n->pitr != NULL)
2569     {
2570 #if DEBUG_CORE
2571       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2572                   "Key exchange in progress with `%4s'.\n",
2573                   GNUNET_i2s (&n->peer));
2574 #endif
2575       return; /* already in progress */
2576     }
2577   if (GNUNET_YES != n->is_connected)
2578     {
2579 #if DEBUG_CORE
2580       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2581                   "Not yet connected to peer `%4s'!\n",
2582                   GNUNET_i2s (&n->peer));
2583 #endif
2584       if (NULL == n->th)
2585         {
2586           GNUNET_STATISTICS_update (stats,
2587                                     gettext_noop ("# Asking transport to connect (for SET_KEY)"),
2588                                     1,
2589                                     GNUNET_NO);
2590           n->th = GNUNET_TRANSPORT_notify_transmit_ready (transport,
2591                                                           &n->peer,
2592                                                           sizeof (struct SetKeyMessage) + sizeof (struct PingMessage),
2593                                                           0,
2594                                                           GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2595                                                           &notify_encrypted_transmit_ready,
2596                                                           n);
2597         }
2598       return;
2599     }
2600 #if DEBUG_CORE
2601   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2602               "Asked to perform key exchange with `%4s'.\n",
2603               GNUNET_i2s (&n->peer));
2604 #endif
2605   if (n->public_key == NULL)
2606     {
2607       /* lookup n's public key, then try again */
2608 #if DEBUG_CORE
2609       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2610                   "Lacking public key for `%4s', trying to obtain one (send_key).\n",
2611                   GNUNET_i2s (&n->peer));
2612 #endif
2613       GNUNET_assert (n->pitr == NULL);
2614       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
2615                                          &n->peer,
2616                                          GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20),
2617                                          &process_hello_retry_send_key, n);
2618       return;
2619     }
2620   pos = n->encrypted_head;
2621   while (pos != NULL)
2622     {
2623       if (GNUNET_YES == pos->is_setkey)
2624         {
2625           if (pos->sender_status == n->status)
2626             {
2627 #if DEBUG_CORE
2628               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2629                           "`%s' message for `%4s' queued already\n",
2630                           "SET_KEY",
2631                           GNUNET_i2s (&n->peer));
2632 #endif
2633               goto trigger_processing;
2634             }
2635           GNUNET_CONTAINER_DLL_remove (n->encrypted_head,
2636                                        n->encrypted_tail,
2637                                        pos);
2638           GNUNET_free (pos);
2639 #if DEBUG_CORE
2640           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2641                       "Removing queued `%s' message for `%4s', will create a new one\n",
2642                       "SET_KEY",
2643                       GNUNET_i2s (&n->peer));
2644 #endif
2645           break;
2646         }
2647       pos = pos->next;
2648     }
2649
2650   /* update status */
2651   switch (n->status)
2652     {
2653     case PEER_STATE_DOWN:
2654       n->status = PEER_STATE_KEY_SENT;
2655       break;
2656     case PEER_STATE_KEY_SENT:
2657       break;
2658     case PEER_STATE_KEY_RECEIVED:
2659       break;
2660     case PEER_STATE_KEY_CONFIRMED:
2661       break;
2662     default:
2663       GNUNET_break (0);
2664       break;
2665     }
2666
2667
2668   /* first, set key message */
2669   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2670                       sizeof (struct SetKeyMessage) +
2671                       sizeof (struct PingMessage));
2672   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_SET_KEY_DELAY);
2673   me->priority = SET_KEY_PRIORITY;
2674   me->size = sizeof (struct SetKeyMessage) + sizeof (struct PingMessage);
2675   me->is_setkey = GNUNET_YES;
2676   me->got_slack = GNUNET_YES; /* do not defer this one! */
2677   me->sender_status = n->status;
2678   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2679                                      n->encrypted_tail,
2680                                      n->encrypted_tail,
2681                                      me);
2682   sm = (struct SetKeyMessage *) &me[1];
2683   sm->header.size = htons (sizeof (struct SetKeyMessage));
2684   sm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_SET_KEY);
2685   sm->sender_status = htonl ((int32_t) ((n->status == PEER_STATE_DOWN) ?
2686                                         PEER_STATE_KEY_SENT : n->status));
2687   sm->purpose.size =
2688     htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
2689            sizeof (struct GNUNET_TIME_AbsoluteNBO) +
2690            sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
2691            sizeof (struct GNUNET_PeerIdentity));
2692   sm->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SET_KEY);
2693   sm->creation_time = GNUNET_TIME_absolute_hton (n->encrypt_key_created);
2694   sm->target = n->peer;
2695   GNUNET_assert (GNUNET_OK ==
2696                  GNUNET_CRYPTO_rsa_encrypt (&n->encrypt_key,
2697                                             sizeof (struct
2698                                                     GNUNET_CRYPTO_AesSessionKey),
2699                                             n->public_key,
2700                                             &sm->encrypted_key));
2701   GNUNET_assert (GNUNET_OK ==
2702                  GNUNET_CRYPTO_rsa_sign (my_private_key, &sm->purpose,
2703                                          &sm->signature));
2704   pm = (struct PingMessage *) &sm[1];
2705   pm->header.size = htons (sizeof (struct PingMessage));
2706   pm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PING);
2707   pp.challenge = htonl (n->ping_challenge);
2708   pp.target = n->peer;
2709 #if DEBUG_HANDSHAKE
2710   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2711               "Encrypting `%s' and `%s' messages with challenge %u for `%4s' using key %u.\n",
2712               "SET_KEY", "PING",
2713               (unsigned int) n->ping_challenge,
2714               GNUNET_i2s (&n->peer),
2715               (unsigned int) n->encrypt_key.crc32);
2716 #endif
2717   do_encrypt (n,
2718               &n->peer.hashPubKey,
2719               &pp.challenge,
2720               &pm->challenge,
2721               sizeof (struct PingMessage) -
2722               sizeof (struct GNUNET_MessageHeader));
2723   GNUNET_STATISTICS_update (stats,
2724                             gettext_noop ("# SET_KEY and PING messages created"),
2725                             1,
2726                             GNUNET_NO);
2727 #if DEBUG_CORE
2728   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2729               "Have %llu ms left for `%s' transmission.\n",
2730               (unsigned long long) GNUNET_TIME_absolute_get_remaining (me->deadline).value,
2731               "SET_KEY");
2732 #endif
2733  trigger_processing:
2734   /* trigger queue processing */
2735   process_encrypted_neighbour_queue (n);
2736   if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
2737        (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
2738     n->retry_set_key_task
2739       = GNUNET_SCHEDULER_add_delayed (sched,
2740                                       n->set_key_retry_frequency,
2741                                       &set_key_retry_task, n);
2742 }
2743
2744
2745 /**
2746  * We received a SET_KEY message.  Validate and update
2747  * our key material and status.
2748  *
2749  * @param n the neighbour from which we received message m
2750  * @param m the set key message we received
2751  */
2752 static void
2753 handle_set_key (struct Neighbour *n,
2754                 const struct SetKeyMessage *m);
2755
2756
2757 /**
2758  * PEERINFO is giving us a HELLO for a peer.  Add the public key to
2759  * the neighbour's struct and retry handling the set_key message.  Or,
2760  * if we did not get a HELLO, just free the set key message.
2761  *
2762  * @param cls pointer to the set key message
2763  * @param peer the peer for which this is the HELLO
2764  * @param hello HELLO message of that peer
2765  */
2766 static void
2767 process_hello_retry_handle_set_key (void *cls,
2768                                     const struct GNUNET_PeerIdentity *peer,
2769                                     const struct GNUNET_HELLO_Message *hello)
2770 {
2771   struct Neighbour *n = cls;
2772   struct SetKeyMessage *sm = n->skm;
2773
2774   if (peer == NULL)
2775     {
2776       n->skm = NULL;
2777       n->pitr = NULL;
2778       if (n->public_key != NULL)
2779         {
2780 #if DEBUG_CORE
2781           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2782                       "Received `%s' for `%4s', continuing processing of `%s' message.\n",
2783                       "HELLO",
2784                       GNUNET_i2s (&n->peer),
2785                       "SET_KEY");
2786 #endif
2787           handle_set_key (n, sm);
2788         }
2789       else
2790         {
2791           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2792                       _("Ignoring `%s' message due to lack of public key for peer `%4s' (failed to obtain one).\n"),
2793                       "SET_KEY",
2794                       GNUNET_i2s (&n->peer));
2795         }
2796       GNUNET_free (sm);
2797       return;
2798     }
2799   if (n->public_key != NULL)
2800     return;                     /* multiple HELLOs match!? */
2801   n->public_key =
2802     GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
2803   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, n->public_key))
2804     {
2805       GNUNET_break_op (0);
2806       GNUNET_free (n->public_key);
2807       n->public_key = NULL;
2808     }
2809 }
2810
2811
2812 /**
2813  * We received a PING message.  Validate and transmit
2814  * PONG.
2815  *
2816  * @param n sender of the PING
2817  * @param m the encrypted PING message itself
2818  */
2819 static void
2820 handle_ping (struct Neighbour *n, const struct PingMessage *m)
2821 {
2822   struct PingMessage t;
2823   struct PongMessage tx;
2824   struct PongMessage *tp;
2825   struct MessageEntry *me;
2826
2827 #if DEBUG_CORE
2828   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2829               "Core service receives `%s' request from `%4s'.\n",
2830               "PING", GNUNET_i2s (&n->peer));
2831 #endif
2832   if (GNUNET_OK !=
2833       do_decrypt (n,
2834                   &my_identity.hashPubKey,
2835                   &m->challenge,
2836                   &t.challenge,
2837                   sizeof (struct PingMessage) -
2838                   sizeof (struct GNUNET_MessageHeader)))
2839     return;
2840 #if DEBUG_HANDSHAKE
2841   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2842               "Decrypted `%s' to `%4s' with challenge %u decrypted using key %u\n",
2843               "PING",
2844               GNUNET_i2s (&t.target),
2845               (unsigned int) ntohl (t.challenge),
2846               (unsigned int) n->decrypt_key.crc32);
2847 #endif
2848   GNUNET_STATISTICS_update (stats,
2849                             gettext_noop ("# PING messages decrypted"),
2850                             1,
2851                             GNUNET_NO);
2852   if (0 != memcmp (&t.target,
2853                    &my_identity, sizeof (struct GNUNET_PeerIdentity)))
2854     {
2855       GNUNET_break_op (0);
2856       return;
2857     }
2858   me = GNUNET_malloc (sizeof (struct MessageEntry) +
2859                       sizeof (struct PongMessage));
2860   GNUNET_CONTAINER_DLL_insert_after (n->encrypted_head,
2861                                      n->encrypted_tail,
2862                                      n->encrypted_tail,
2863                                      me);
2864   me->deadline = GNUNET_TIME_relative_to_absolute (MAX_PONG_DELAY);
2865   me->priority = PONG_PRIORITY;
2866   me->size = sizeof (struct PongMessage);
2867   tx.reserved = htonl (0);
2868   tx.inbound_bw_limit = n->bw_in;
2869   tx.challenge = t.challenge;
2870   tx.target = t.target;
2871   tp = (struct PongMessage *) &me[1];
2872   tp->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_PONG);
2873   tp->header.size = htons (sizeof (struct PongMessage));
2874   do_encrypt (n,
2875               &my_identity.hashPubKey,
2876               &tx.challenge,
2877               &tp->challenge,
2878               sizeof (struct PongMessage) -
2879               sizeof (struct GNUNET_MessageHeader));
2880   GNUNET_STATISTICS_update (stats,
2881                             gettext_noop ("# PONG messages created"),
2882                             1,
2883                             GNUNET_NO);
2884 #if DEBUG_HANDSHAKE
2885   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2886               "Encrypting `%s' with challenge %u using key %u\n",
2887               "PONG",
2888               (unsigned int) ntohl (t.challenge),
2889               (unsigned int) n->encrypt_key.crc32);
2890 #endif
2891   /* trigger queue processing */
2892   process_encrypted_neighbour_queue (n);
2893 }
2894
2895
2896 /**
2897  * We received a PONG message.  Validate and update our status.
2898  *
2899  * @param n sender of the PONG
2900  * @param m the encrypted PONG message itself
2901  */
2902 static void
2903 handle_pong (struct Neighbour *n,
2904              const struct PongMessage *m)
2905 {
2906   struct PongMessage t;
2907   struct ConnectNotifyMessage cnm;
2908
2909 #if DEBUG_CORE
2910   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2911               "Core service receives `%s' response from `%4s'.\n",
2912               "PONG", GNUNET_i2s (&n->peer));
2913 #endif
2914   /* mark as garbage, just to be sure */
2915   memset (&t, 255, sizeof (t));
2916   if (GNUNET_OK !=
2917       do_decrypt (n,
2918                   &n->peer.hashPubKey,
2919                   &m->challenge,
2920                   &t.challenge,
2921                   sizeof (struct PongMessage) -
2922                   sizeof (struct GNUNET_MessageHeader)))
2923     {
2924       GNUNET_break_op (0);
2925       return;
2926     }
2927   GNUNET_STATISTICS_update (stats,
2928                             gettext_noop ("# PONG messages decrypted"),
2929                             1,
2930                             GNUNET_NO);
2931   if (0 != ntohl (t.reserved))
2932     {
2933       GNUNET_break_op (0);
2934       return;
2935     }
2936 #if DEBUG_HANDSHAKE
2937   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2938               "Decrypted `%s' from `%4s' with challenge %u using key %u\n",
2939               "PONG",
2940               GNUNET_i2s (&t.target),
2941               (unsigned int) ntohl (t.challenge),
2942               (unsigned int) n->decrypt_key.crc32);
2943 #endif
2944   if ((0 != memcmp (&t.target,
2945                     &n->peer,
2946                     sizeof (struct GNUNET_PeerIdentity))) ||
2947       (n->ping_challenge != ntohl (t.challenge)))
2948     {
2949       /* PONG malformed */
2950 #if DEBUG_CORE
2951       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2952                   "Received malformed `%s' wanted sender `%4s' with challenge %u\n",
2953                   "PONG",
2954                   GNUNET_i2s (&n->peer),
2955                   (unsigned int) n->ping_challenge);
2956       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2957                   "Received malformed `%s' received from `%4s' with challenge %u\n",
2958                   "PONG", GNUNET_i2s (&t.target),
2959                   (unsigned int) ntohl (t.challenge));
2960 #endif
2961       GNUNET_break_op (0);
2962       return;
2963     }
2964   switch (n->status)
2965     {
2966     case PEER_STATE_DOWN:
2967       GNUNET_break (0);         /* should be impossible */
2968       return;
2969     case PEER_STATE_KEY_SENT:
2970       GNUNET_break (0);         /* should be impossible, how did we decrypt? */
2971       return;
2972     case PEER_STATE_KEY_RECEIVED:
2973       GNUNET_STATISTICS_update (stats,
2974                                 gettext_noop ("# Session keys confirmed via PONG"),
2975                                 1,
2976                                 GNUNET_NO);
2977       n->status = PEER_STATE_KEY_CONFIRMED;
2978       if (n->bw_out_external_limit.value__ != t.inbound_bw_limit.value__)
2979         {
2980           n->bw_out_external_limit = t.inbound_bw_limit;
2981           n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
2982                                                   n->bw_out_internal_limit);
2983           GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
2984                                                  n->bw_out);
2985           GNUNET_TRANSPORT_set_quota (transport,
2986                                       &n->peer,
2987                                       n->bw_in,
2988                                       n->bw_out,
2989                                       GNUNET_TIME_UNIT_FOREVER_REL,
2990                                       NULL, NULL);
2991         }
2992 #if DEBUG_CORE
2993       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2994                   "Confirmed key via `%s' message for peer `%4s'\n",
2995                   "PONG", GNUNET_i2s (&n->peer));
2996 #endif
2997       if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
2998         {
2999           GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
3000           n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
3001         }
3002       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
3003       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT);
3004       cnm.distance = htonl (n->last_distance);
3005       cnm.latency = GNUNET_TIME_relative_hton (n->last_latency);
3006       cnm.peer = n->peer;
3007       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_CONNECT);
3008       process_encrypted_neighbour_queue (n);
3009       /* fall-through! */
3010     case PEER_STATE_KEY_CONFIRMED:
3011       n->last_activity = GNUNET_TIME_absolute_get ();
3012       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3013         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3014       n->keep_alive_task
3015         = GNUNET_SCHEDULER_add_delayed (sched,
3016                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3017                                         &send_keep_alive,
3018                                         n);
3019       handle_peer_status_change (n);
3020       break;
3021     default:
3022       GNUNET_break (0);
3023       break;
3024     }
3025 }
3026
3027
3028 /**
3029  * We received a SET_KEY message.  Validate and update
3030  * our key material and status.
3031  *
3032  * @param n the neighbour from which we received message m
3033  * @param m the set key message we received
3034  */
3035 static void
3036 handle_set_key (struct Neighbour *n, const struct SetKeyMessage *m)
3037 {
3038   struct SetKeyMessage *m_cpy;
3039   struct GNUNET_TIME_Absolute t;
3040   struct GNUNET_CRYPTO_AesSessionKey k;
3041   struct PingMessage *ping;
3042   struct PongMessage *pong;
3043   enum PeerStateMachine sender_status;
3044
3045 #if DEBUG_CORE
3046   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3047               "Core service receives `%s' request from `%4s'.\n",
3048               "SET_KEY", GNUNET_i2s (&n->peer));
3049 #endif
3050   if (n->public_key == NULL)
3051     {
3052       if (n->pitr != NULL)
3053         {
3054 #if DEBUG_CORE
3055           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3056                       "Ignoring `%s' message due to lack of public key for peer (still trying to obtain one).\n",
3057                       "SET_KEY");
3058 #endif
3059           return;
3060         }
3061 #if DEBUG_CORE
3062       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3063                   "Lacking public key for peer, trying to obtain one (handle_set_key).\n");
3064 #endif
3065       m_cpy = GNUNET_malloc (sizeof (struct SetKeyMessage));
3066       memcpy (m_cpy, m, sizeof (struct SetKeyMessage));
3067       /* lookup n's public key, then try again */
3068       GNUNET_assert (n->skm == NULL);
3069       n->skm = m_cpy;
3070       n->pitr = GNUNET_PEERINFO_iterate (peerinfo,
3071                                          &n->peer,
3072                                          GNUNET_TIME_UNIT_MINUTES,
3073                                          &process_hello_retry_handle_set_key, n);
3074       GNUNET_STATISTICS_update (stats,
3075                                 gettext_noop ("# SET_KEY messages deferred (need public key)"),
3076                                 1,
3077                                 GNUNET_NO);
3078       return;
3079     }
3080   if (0 != memcmp (&m->target,
3081                    &my_identity,
3082                    sizeof (struct GNUNET_PeerIdentity)))
3083     {
3084       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3085                   _("Received `%s' message that was for `%s', not for me.  Ignoring.\n"),
3086                   "SET_KEY",
3087                   GNUNET_i2s (&m->target));
3088       return;
3089     }
3090   if ((ntohl (m->purpose.size) !=
3091        sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
3092        sizeof (struct GNUNET_TIME_AbsoluteNBO) +
3093        sizeof (struct GNUNET_CRYPTO_RsaEncryptedData) +
3094        sizeof (struct GNUNET_PeerIdentity)) ||
3095       (GNUNET_OK !=
3096        GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_SET_KEY,
3097                                  &m->purpose, &m->signature, n->public_key)))
3098     {
3099       /* invalid signature */
3100       GNUNET_break_op (0);
3101       return;
3102     }
3103   t = GNUNET_TIME_absolute_ntoh (m->creation_time);
3104   if (((n->status == PEER_STATE_KEY_RECEIVED) ||
3105        (n->status == PEER_STATE_KEY_CONFIRMED)) &&
3106       (t.value < n->decrypt_key_created.value))
3107     {
3108       /* this could rarely happen due to massive re-ordering of
3109          messages on the network level, but is most likely either
3110          a bug or some adversary messing with us.  Report. */
3111       GNUNET_break_op (0);
3112       return;
3113     }
3114 #if DEBUG_CORE
3115   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3116               "Decrypting key material.\n");
3117 #endif
3118   if ((GNUNET_CRYPTO_rsa_decrypt (my_private_key,
3119                                   &m->encrypted_key,
3120                                   &k,
3121                                   sizeof (struct GNUNET_CRYPTO_AesSessionKey))
3122        != sizeof (struct GNUNET_CRYPTO_AesSessionKey)) ||
3123       (GNUNET_OK != GNUNET_CRYPTO_aes_check_session_key (&k)))
3124     {
3125       /* failed to decrypt !? */
3126       GNUNET_break_op (0);
3127       return;
3128     }
3129   GNUNET_STATISTICS_update (stats,
3130                             gettext_noop ("# SET_KEY messages decrypted"),
3131                             1,
3132                             GNUNET_NO);
3133   n->decrypt_key = k;
3134   if (n->decrypt_key_created.value != t.value)
3135     {
3136       /* fresh key, reset sequence numbers */
3137       n->last_sequence_number_received = 0;
3138       n->last_packets_bitmap = 0;
3139       n->decrypt_key_created = t;
3140     }
3141   sender_status = (enum PeerStateMachine) ntohl (m->sender_status);
3142   switch (n->status)
3143     {
3144     case PEER_STATE_DOWN:
3145       n->status = PEER_STATE_KEY_RECEIVED;
3146 #if DEBUG_CORE
3147       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3148                   "Responding to `%s' with my own key.\n", "SET_KEY");
3149 #endif
3150       send_key (n);
3151       break;
3152     case PEER_STATE_KEY_SENT:
3153     case PEER_STATE_KEY_RECEIVED:
3154       n->status = PEER_STATE_KEY_RECEIVED;
3155       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3156           (sender_status != PEER_STATE_KEY_CONFIRMED))
3157         {
3158 #if DEBUG_CORE
3159           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3160                       "Responding to `%s' with my own key (other peer has status %u).\n",
3161                       "SET_KEY",
3162                       (unsigned int) sender_status);
3163 #endif
3164           send_key (n);
3165         }
3166       break;
3167     case PEER_STATE_KEY_CONFIRMED:
3168       if ((sender_status != PEER_STATE_KEY_RECEIVED) &&
3169           (sender_status != PEER_STATE_KEY_CONFIRMED))
3170         {
3171 #if DEBUG_CORE
3172           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3173                       "Responding to `%s' with my own key (other peer has status %u), I was already fully up.\n",
3174                       "SET_KEY",
3175                       (unsigned int) sender_status);
3176 #endif
3177           send_key (n);
3178         }
3179       break;
3180     default:
3181       GNUNET_break (0);
3182       break;
3183     }
3184   if (n->pending_ping != NULL)
3185     {
3186       ping = n->pending_ping;
3187       n->pending_ping = NULL;
3188       handle_ping (n, ping);
3189       GNUNET_free (ping);
3190     }
3191   if (n->pending_pong != NULL)
3192     {
3193       pong = n->pending_pong;
3194       n->pending_pong = NULL;
3195       handle_pong (n, pong);
3196       GNUNET_free (pong);
3197     }
3198 }
3199
3200
3201 /**
3202  * Send a P2P message to a client.
3203  *
3204  * @param sender who sent us the message?
3205  * @param client who should we give the message to?
3206  * @param m contains the message to transmit
3207  * @param msize number of bytes in buf to transmit
3208  */
3209 static void
3210 send_p2p_message_to_client (struct Neighbour *sender,
3211                             struct Client *client,
3212                             const void *m, size_t msize)
3213 {
3214   char buf[msize + sizeof (struct NotifyTrafficMessage)];
3215   struct NotifyTrafficMessage *ntm;
3216
3217 #if DEBUG_CORE
3218   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3219               "Core service passes message from `%4s' of type %u to client.\n",
3220               GNUNET_i2s(&sender->peer),
3221               (unsigned int) ntohs (((const struct GNUNET_MessageHeader *) m)->type));
3222 #endif
3223   ntm = (struct NotifyTrafficMessage *) buf;
3224   ntm->header.size = htons (msize + sizeof (struct NotifyTrafficMessage));
3225   ntm->header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND);
3226   ntm->distance = htonl (sender->last_distance);
3227   ntm->latency = GNUNET_TIME_relative_hton (sender->last_latency);
3228   ntm->peer = sender->peer;
3229   memcpy (&ntm[1], m, msize);
3230   send_to_client (client, &ntm->header, GNUNET_YES);
3231 }
3232
3233
3234 /**
3235  * Deliver P2P message to interested clients.
3236  *
3237  * @param cls always NULL
3238  * @param client who sent us the message (struct Neighbour)
3239  * @param m the message
3240  */
3241 static void
3242 deliver_message (void *cls,
3243                  void *client,
3244                  const struct GNUNET_MessageHeader *m)
3245 {
3246   struct Neighbour *sender = client;
3247   size_t msize = ntohs (m->size);
3248   char buf[256];
3249   struct Client *cpos;
3250   uint16_t type;
3251   unsigned int tpos;
3252   int deliver_full;
3253   int dropped;
3254
3255   type = ntohs (m->type);
3256 #if DEBUG_CORE
3257   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3258               "Received encapsulated message of type %u and size %u from `%4s'\n",
3259               (unsigned int) type,
3260               ntohs (m->size),
3261               GNUNET_i2s (&sender->peer));
3262 #endif
3263   GNUNET_snprintf (buf,
3264                    sizeof(buf),
3265                    gettext_noop ("# bytes of messages of type %u received"),
3266                    (unsigned int) type);
3267   GNUNET_STATISTICS_set (stats,
3268                          buf,
3269                          msize,
3270                          GNUNET_NO);
3271   dropped = GNUNET_YES;
3272   cpos = clients;
3273   while (cpos != NULL)
3274     {
3275       deliver_full = GNUNET_NO;
3276       if (0 != (cpos->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND))
3277         deliver_full = GNUNET_YES;
3278       else
3279         {
3280           for (tpos = 0; tpos < cpos->tcnt; tpos++)
3281             {
3282               if (type != cpos->types[tpos])
3283                 continue;
3284               deliver_full = GNUNET_YES;
3285               break;
3286             }
3287         }
3288       if (GNUNET_YES == deliver_full)
3289         {
3290           send_p2p_message_to_client (sender, cpos, m, msize);
3291           dropped = GNUNET_NO;
3292         }
3293       else if (cpos->options & GNUNET_CORE_OPTION_SEND_HDR_INBOUND)
3294         {
3295           send_p2p_message_to_client (sender, cpos, m,
3296                                       sizeof (struct GNUNET_MessageHeader));
3297         }
3298       cpos = cpos->next;
3299     }
3300   if (dropped == GNUNET_YES)
3301     {
3302 #if DEBUG_CORE
3303       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3304                   "Message of type %u from `%4s' not delivered to any client.\n",
3305                   (unsigned int) type,
3306                   GNUNET_i2s (&sender->peer));
3307 #endif
3308       GNUNET_STATISTICS_update (stats,
3309                                 gettext_noop ("# messages not delivered to any client"),
3310                                 1, GNUNET_NO);
3311     }
3312 }
3313
3314
3315 /**
3316  * We received an encrypted message.  Decrypt, validate and
3317  * pass on to the appropriate clients.
3318  */
3319 static void
3320 handle_encrypted_message (struct Neighbour *n,
3321                           const struct EncryptedMessage *m)
3322 {
3323   size_t size = ntohs (m->header.size);
3324   char buf[size];
3325   struct EncryptedMessage *pt;  /* plaintext */
3326   GNUNET_HashCode ph;
3327   uint32_t snum;
3328   struct GNUNET_TIME_Absolute t;
3329   GNUNET_HashCode iv;
3330
3331 #if DEBUG_CORE
3332   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3333               "Core service receives `%s' request from `%4s'.\n",
3334               "ENCRYPTED_MESSAGE", GNUNET_i2s (&n->peer));
3335 #endif
3336   GNUNET_CRYPTO_hash (&m->iv_seed, sizeof (uint32_t), &iv);
3337   /* decrypt */
3338   if (GNUNET_OK !=
3339       do_decrypt (n,
3340                   &iv,
3341                   &m->hmac,
3342                   &buf[ENCRYPTED_HEADER_SIZE],
3343                   size - ENCRYPTED_HEADER_SIZE))
3344     return;
3345   pt = (struct EncryptedMessage *) buf;
3346   /* validate hash */
3347   GNUNET_CRYPTO_hmac (&n->decrypt_key,
3348                       &pt->sequence_number,
3349                       size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode), &ph);
3350 #if DEBUG_HANDSHAKE
3351   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3352               "V-Hashed %u bytes of plaintext (`%s') using IV `%d'\n",
3353               (unsigned int) (size - ENCRYPTED_HEADER_SIZE - sizeof (GNUNET_HashCode)),
3354               GNUNET_h2s (&ph),
3355               (int) m->iv_seed);
3356 #endif
3357   if (0 != memcmp (&ph,
3358                    &pt->hmac,
3359                    sizeof (GNUNET_HashCode)))
3360     {
3361       /* checksum failed */
3362       GNUNET_break_op (0);
3363       return;
3364     }
3365
3366   /* validate sequence number */
3367   snum = ntohl (pt->sequence_number);
3368   if (n->last_sequence_number_received == snum)
3369     {
3370       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3371                   "Received duplicate message, ignoring.\n");
3372       /* duplicate, ignore */
3373       GNUNET_STATISTICS_set (stats,
3374                              gettext_noop ("# bytes dropped (duplicates)"),
3375                              size,
3376                              GNUNET_NO);
3377       return;
3378     }
3379   if ((n->last_sequence_number_received > snum) &&
3380       (n->last_sequence_number_received - snum > 32))
3381     {
3382       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3383                   "Received ancient out of sequence message, ignoring.\n");
3384       /* ancient out of sequence, ignore */
3385       GNUNET_STATISTICS_set (stats,
3386                              gettext_noop ("# bytes dropped (out of sequence)"),
3387                              size,
3388                              GNUNET_NO);
3389       return;
3390     }
3391   if (n->last_sequence_number_received > snum)
3392     {
3393       unsigned int rotbit =
3394         1 << (n->last_sequence_number_received - snum - 1);
3395       if ((n->last_packets_bitmap & rotbit) != 0)
3396         {
3397           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3398                       "Received duplicate message, ignoring.\n");
3399           GNUNET_STATISTICS_set (stats,
3400                                  gettext_noop ("# bytes dropped (duplicates)"),
3401                                  size,
3402                                  GNUNET_NO);
3403           /* duplicate, ignore */
3404           return;
3405         }
3406       n->last_packets_bitmap |= rotbit;
3407     }
3408   if (n->last_sequence_number_received < snum)
3409     {
3410       n->last_packets_bitmap <<= (snum - n->last_sequence_number_received);
3411       n->last_sequence_number_received = snum;
3412     }
3413
3414   /* check timestamp */
3415   t = GNUNET_TIME_absolute_ntoh (pt->timestamp);
3416   if (GNUNET_TIME_absolute_get_duration (t).value > MAX_MESSAGE_AGE.value)
3417     {
3418       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3419                   _
3420                   ("Message received far too old (%llu ms). Content ignored.\n"),
3421                   GNUNET_TIME_absolute_get_duration (t).value);
3422       GNUNET_STATISTICS_set (stats,
3423                              gettext_noop ("# bytes dropped (ancient message)"),
3424                              size,
3425                              GNUNET_NO);
3426       return;
3427     }
3428
3429   /* process decrypted message(s) */
3430   if (n->bw_out_external_limit.value__ != pt->inbound_bw_limit.value__)
3431     {
3432 #if DEBUG_CORE_SET_QUOTA
3433       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3434                   "Received %u b/s as new inbound limit for peer `%4s'\n",
3435                   (unsigned int) ntohl (pt->inbound_bw_limit.value__),
3436                   GNUNET_i2s (&n->peer));
3437 #endif
3438       n->bw_out_external_limit = pt->inbound_bw_limit;
3439       n->bw_out = GNUNET_BANDWIDTH_value_min (n->bw_out_external_limit,
3440                                               n->bw_out_internal_limit);
3441       GNUNET_BANDWIDTH_tracker_update_quota (&n->available_send_window,
3442                                              n->bw_out);
3443       GNUNET_TRANSPORT_set_quota (transport,
3444                                   &n->peer,
3445                                   n->bw_in,
3446                                   n->bw_out,
3447                                   GNUNET_TIME_UNIT_FOREVER_REL,
3448                                   NULL, NULL);
3449     }
3450   n->last_activity = GNUNET_TIME_absolute_get ();
3451   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3452     GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3453   n->keep_alive_task
3454     = GNUNET_SCHEDULER_add_delayed (sched,
3455                                     GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3456                                     &send_keep_alive,
3457                                     n);
3458   GNUNET_STATISTICS_set (stats,
3459                          gettext_noop ("# bytes of payload decrypted"),
3460                          size - sizeof (struct EncryptedMessage),
3461                          GNUNET_NO);
3462   handle_peer_status_change (n);
3463   if (GNUNET_OK != GNUNET_SERVER_mst_receive (mst,
3464                                               n,
3465                                               &buf[sizeof (struct EncryptedMessage)],
3466                                               size - sizeof (struct EncryptedMessage),
3467                                               GNUNET_YES, GNUNET_NO))
3468     GNUNET_break_op (0);
3469 }
3470
3471
3472 /**
3473  * Function called by the transport for each received message.
3474  *
3475  * @param cls closure
3476  * @param peer (claimed) identity of the other peer
3477  * @param message the message
3478  * @param latency estimated latency for communicating with the
3479  *             given peer (round-trip)
3480  * @param distance in overlay hops, as given by transport plugin
3481  */
3482 static void
3483 handle_transport_receive (void *cls,
3484                           const struct GNUNET_PeerIdentity *peer,
3485                           const struct GNUNET_MessageHeader *message,
3486                           struct GNUNET_TIME_Relative latency,
3487                           unsigned int distance)
3488 {
3489   struct Neighbour *n;
3490   struct GNUNET_TIME_Absolute now;
3491   int up;
3492   uint16_t type;
3493   uint16_t size;
3494   int changed;
3495
3496 #if DEBUG_CORE
3497   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3498               "Received message of type %u from `%4s', demultiplexing.\n",
3499               (unsigned int) ntohs (message->type),
3500               GNUNET_i2s (peer));
3501 #endif
3502   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3503     {
3504       GNUNET_break (0);
3505       return;
3506     }
3507   n = find_neighbour (peer);
3508   if (n == NULL)
3509     n = create_neighbour (peer);
3510   changed = (latency.value != n->last_latency.value) || (distance != n->last_distance);
3511   n->last_latency = latency;
3512   n->last_distance = distance;
3513   up = (n->status == PEER_STATE_KEY_CONFIRMED);
3514   type = ntohs (message->type);
3515   size = ntohs (message->size);
3516   switch (type)
3517     {
3518     case GNUNET_MESSAGE_TYPE_CORE_SET_KEY:
3519       if (size != sizeof (struct SetKeyMessage))
3520         {
3521           GNUNET_break_op (0);
3522           return;
3523         }
3524       GNUNET_STATISTICS_update (stats, gettext_noop ("# session keys received"), 1, GNUNET_NO);
3525       handle_set_key (n, (const struct SetKeyMessage *) message);
3526       break;
3527     case GNUNET_MESSAGE_TYPE_CORE_ENCRYPTED_MESSAGE:
3528       if (size < sizeof (struct EncryptedMessage) +
3529           sizeof (struct GNUNET_MessageHeader))
3530         {
3531           GNUNET_break_op (0);
3532           return;
3533         }
3534       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3535           (n->status != PEER_STATE_KEY_CONFIRMED))
3536         {
3537           GNUNET_break_op (0);
3538           return;
3539         }
3540       handle_encrypted_message (n, (const struct EncryptedMessage *) message);
3541       break;
3542     case GNUNET_MESSAGE_TYPE_CORE_PING:
3543       if (size != sizeof (struct PingMessage))
3544         {
3545           GNUNET_break_op (0);
3546           return;
3547         }
3548       GNUNET_STATISTICS_update (stats, gettext_noop ("# PING messages received"), 1, GNUNET_NO);
3549       if ((n->status != PEER_STATE_KEY_RECEIVED) &&
3550           (n->status != PEER_STATE_KEY_CONFIRMED))
3551         {
3552 #if DEBUG_CORE
3553           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3554                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3555                       "PING", GNUNET_i2s (&n->peer));
3556 #endif
3557           GNUNET_free_non_null (n->pending_ping);
3558           n->pending_ping = GNUNET_malloc (sizeof (struct PingMessage));
3559           memcpy (n->pending_ping, message, sizeof (struct PingMessage));
3560           return;
3561         }
3562       handle_ping (n, (const struct PingMessage *) message);
3563       break;
3564     case GNUNET_MESSAGE_TYPE_CORE_PONG:
3565       if (size != sizeof (struct PongMessage))
3566         {
3567           GNUNET_break_op (0);
3568           return;
3569         }
3570       GNUNET_STATISTICS_update (stats, gettext_noop ("# PONG messages received"), 1, GNUNET_NO);
3571       if ( (n->status != PEER_STATE_KEY_RECEIVED) &&
3572            (n->status != PEER_STATE_KEY_CONFIRMED) )
3573         {
3574 #if DEBUG_CORE
3575           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3576                       "Core service receives `%s' request from `%4s' but have not processed key; marking as pending.\n",
3577                       "PONG", GNUNET_i2s (&n->peer));
3578 #endif
3579           GNUNET_free_non_null (n->pending_pong);
3580           n->pending_pong = GNUNET_malloc (sizeof (struct PongMessage));
3581           memcpy (n->pending_pong, message, sizeof (struct PongMessage));
3582           return;
3583         }
3584       handle_pong (n, (const struct PongMessage *) message);
3585       break;
3586     default:
3587       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3588                   _("Unsupported message of type %u received.\n"),
3589                   (unsigned int) type);
3590       return;
3591     }
3592   if (n->status == PEER_STATE_KEY_CONFIRMED)
3593     {
3594       now = GNUNET_TIME_absolute_get ();
3595       n->last_activity = now;
3596       changed = GNUNET_YES;
3597       if (!up)
3598         {
3599           GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), 1, GNUNET_NO);
3600           n->time_established = now;
3601         }
3602       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
3603         GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
3604       n->keep_alive_task
3605         = GNUNET_SCHEDULER_add_delayed (sched,
3606                                         GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
3607                                         &send_keep_alive,
3608                                         n);
3609     }
3610   if (changed)
3611     handle_peer_status_change (n);
3612 }
3613
3614
3615 /**
3616  * Function that recalculates the bandwidth quota for the
3617  * given neighbour and transmits it to the transport service.
3618  *
3619  * @param cls neighbour for the quota update
3620  * @param tc context
3621  */
3622 static void
3623 neighbour_quota_update (void *cls,
3624                         const struct GNUNET_SCHEDULER_TaskContext *tc)
3625 {
3626   struct Neighbour *n = cls;
3627   struct GNUNET_BANDWIDTH_Value32NBO q_in;
3628   double pref_rel;
3629   double share;
3630   unsigned long long distributable;
3631   uint64_t need_per_peer;
3632   uint64_t need_per_second;
3633
3634 #if DEBUG_CORE
3635   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3636               "Neighbour quota update calculation running for peer `%4s'\n",
3637               GNUNET_i2s (&n->peer));
3638 #endif
3639   n->quota_update_task = GNUNET_SCHEDULER_NO_TASK;
3640   /* calculate relative preference among all neighbours;
3641      divides by a bit more to avoid division by zero AND to
3642      account for possibility of new neighbours joining any time
3643      AND to convert to double... */
3644   if (preference_sum == 0)
3645     {
3646       pref_rel = 1.0 / (double) neighbour_count;
3647     }
3648   else
3649     {
3650       pref_rel = n->current_preference / preference_sum;
3651     }
3652   need_per_peer = GNUNET_BANDWIDTH_value_get_available_until (MIN_BANDWIDTH_PER_PEER,
3653                                                               GNUNET_TIME_UNIT_SECONDS);
3654   need_per_second = need_per_peer * neighbour_count;
3655   distributable = 0;
3656   if (bandwidth_target_out_bps > need_per_second)
3657     distributable = bandwidth_target_out_bps - need_per_second;
3658   share = distributable * pref_rel;
3659   if (share + need_per_peer > UINT32_MAX)
3660     q_in = GNUNET_BANDWIDTH_value_init (UINT32_MAX);
3661   else
3662     q_in = GNUNET_BANDWIDTH_value_init (need_per_peer + (uint32_t) share);
3663   /* check if we want to disconnect for good due to inactivity */
3664   if ( (GNUNET_TIME_absolute_get_duration (n->last_activity).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) &&
3665        (GNUNET_TIME_absolute_get_duration (n->time_established).value > GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.value) )
3666     {
3667 #if DEBUG_CORE
3668       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3669                   "Forcing disconnect of `%4s' due to inactivity\n",
3670                   GNUNET_i2s (&n->peer));
3671 #endif
3672       q_in = GNUNET_BANDWIDTH_value_init (0); /* force disconnect */
3673     }
3674 #if DEBUG_CORE_QUOTA
3675   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3676               "Current quota for `%4s' is %u/%llu b/s in (old: %u b/s) / %u out (%u internal)\n",
3677               GNUNET_i2s (&n->peer),
3678               (unsigned int) ntohl (q_in.value__),
3679               bandwidth_target_out_bps,
3680               (unsigned int) ntohl (n->bw_in.value__),
3681               (unsigned int) ntohl (n->bw_out.value__),
3682               (unsigned int) ntohl (n->bw_out_internal_limit.value__));
3683 #endif
3684   if (n->bw_in.value__ != q_in.value__)
3685     {
3686       n->bw_in = q_in;
3687       if (GNUNET_YES == n->is_connected)
3688         GNUNET_TRANSPORT_set_quota (transport,
3689                                     &n->peer,
3690                                     n->bw_in,
3691                                     n->bw_out,
3692                                     GNUNET_TIME_UNIT_FOREVER_REL,
3693                                     NULL, NULL);
3694       handle_peer_status_change (n);
3695     }
3696   schedule_quota_update (n);
3697 }
3698
3699
3700 /**
3701  * Function called by transport to notify us that
3702  * a peer connected to us (on the network level).
3703  *
3704  * @param cls closure
3705  * @param peer the peer that connected
3706  * @param latency current latency of the connection
3707  * @param distance in overlay hops, as given by transport plugin
3708  */
3709 static void
3710 handle_transport_notify_connect (void *cls,
3711                                  const struct GNUNET_PeerIdentity *peer,
3712                                  struct GNUNET_TIME_Relative latency,
3713                                  unsigned int distance)
3714 {
3715   struct Neighbour *n;
3716
3717   if (0 == memcmp (peer, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
3718     {
3719       GNUNET_break (0);
3720       return;
3721     }
3722   n = find_neighbour (peer);
3723   if (n != NULL)
3724     {
3725       if (GNUNET_YES == n->is_connected)
3726         {
3727           /* duplicate connect notification!? */
3728           GNUNET_break (0);
3729           return;
3730         }
3731     }
3732   else
3733     {
3734       n = create_neighbour (peer);
3735     }
3736   GNUNET_STATISTICS_update (stats,
3737                             gettext_noop ("# peers connected (transport)"),
3738                             1,
3739                             GNUNET_NO);
3740   n->is_connected = GNUNET_YES;
3741   n->last_latency = latency;
3742   n->last_distance = distance;
3743   GNUNET_BANDWIDTH_tracker_init (&n->available_send_window,
3744                                  n->bw_out,
3745                                  MAX_WINDOW_TIME_S);
3746   GNUNET_BANDWIDTH_tracker_init (&n->available_recv_window,
3747                                  n->bw_in,
3748                                  MAX_WINDOW_TIME_S);
3749 #if DEBUG_CORE
3750   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3751               "Received connection from `%4s'.\n",
3752               GNUNET_i2s (&n->peer));
3753 #endif
3754   GNUNET_TRANSPORT_set_quota (transport,
3755                               &n->peer,
3756                               n->bw_in,
3757                               n->bw_out,
3758                               GNUNET_TIME_UNIT_FOREVER_REL,
3759                               NULL, NULL);
3760   send_key (n);
3761 }
3762
3763
3764 /**
3765  * Function called by transport telling us that a peer
3766  * disconnected.
3767  *
3768  * @param cls closure
3769  * @param peer the peer that disconnected
3770  */
3771 static void
3772 handle_transport_notify_disconnect (void *cls,
3773                                     const struct GNUNET_PeerIdentity *peer)
3774 {
3775   struct DisconnectNotifyMessage cnm;
3776   struct Neighbour *n;
3777   struct GNUNET_TIME_Relative left;
3778
3779 #if DEBUG_CORE
3780   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3781               "Peer `%4s' disconnected from us; received notification from transport.\n", GNUNET_i2s (peer));
3782 #endif
3783
3784   n = find_neighbour (peer);
3785   if (n == NULL)
3786     {
3787       GNUNET_break (0);
3788       return;
3789     }
3790   GNUNET_break (n->is_connected);
3791   if (n->status == PEER_STATE_KEY_CONFIRMED)
3792     {
3793       cnm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
3794       cnm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
3795       cnm.peer = *peer;
3796       send_to_all_clients (&cnm.header, GNUNET_YES, GNUNET_CORE_OPTION_SEND_DISCONNECT);
3797     }
3798   n->is_connected = GNUNET_NO;
3799   GNUNET_STATISTICS_update (stats,
3800                             gettext_noop ("# peers connected (transport)"),
3801                             -1,
3802                             GNUNET_NO);
3803   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
3804     GNUNET_SCHEDULER_cancel (sched,
3805                              n->dead_clean_task);
3806   left = GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
3807                                         GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
3808   n->last_activity = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (),
3809                                                     left);
3810   n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
3811                                                      GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
3812                                                      &consider_free_task,
3813                                                      n);
3814 }
3815
3816
3817 /**
3818  * Last task run during shutdown.  Disconnects us from
3819  * the transport.
3820  */
3821 static void
3822 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
3823 {
3824   struct Neighbour *n;
3825   struct Client *c;
3826
3827 #if DEBUG_CORE
3828   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3829               "Core service shutting down.\n");
3830 #endif
3831   GNUNET_assert (transport != NULL);
3832   GNUNET_TRANSPORT_disconnect (transport);
3833   transport = NULL;
3834   while (NULL != (n = neighbours))
3835     {
3836       neighbours = n->next;
3837       GNUNET_assert (neighbour_count > 0);
3838       neighbour_count--;
3839       free_neighbour (n);
3840     }
3841   GNUNET_STATISTICS_set (stats, gettext_noop ("# neighbour entries allocated"), neighbour_count, GNUNET_NO);
3842   GNUNET_SERVER_notification_context_destroy (notifier);
3843   notifier = NULL;
3844   while (NULL != (c = clients))
3845     handle_client_disconnect (NULL, c->client_handle);
3846   if (my_private_key != NULL)
3847     GNUNET_CRYPTO_rsa_key_free (my_private_key);
3848   if (stats != NULL)
3849     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
3850   if (peerinfo != NULL)
3851     GNUNET_PEERINFO_disconnect (peerinfo);
3852   if (mst != NULL)
3853     GNUNET_SERVER_mst_destroy (mst);
3854 }
3855
3856
3857 /**
3858  * Initiate core service.
3859  *
3860  * @param cls closure
3861  * @param s scheduler to use
3862  * @param server the initialized server
3863  * @param c configuration to use
3864  */
3865 static void
3866 run (void *cls,
3867      struct GNUNET_SCHEDULER_Handle *s,
3868      struct GNUNET_SERVER_Handle *server,
3869      const struct GNUNET_CONFIGURATION_Handle *c)
3870 {
3871   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
3872     {&handle_client_init, NULL,
3873      GNUNET_MESSAGE_TYPE_CORE_INIT, 0},
3874     {&handle_client_request_info, NULL,
3875      GNUNET_MESSAGE_TYPE_CORE_REQUEST_INFO,
3876      sizeof (struct RequestInfoMessage)},
3877     {&handle_client_iterate_peers, NULL,
3878      GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS,
3879      sizeof (struct GNUNET_MessageHeader)},
3880     {&handle_client_send, NULL,
3881      GNUNET_MESSAGE_TYPE_CORE_SEND, 0},
3882     {&handle_client_request_connect, NULL,
3883      GNUNET_MESSAGE_TYPE_CORE_REQUEST_CONNECT,
3884      sizeof (struct ConnectMessage)},
3885     {NULL, NULL, 0, 0}
3886   };
3887   char *keyfile;
3888
3889   sched = s;
3890   cfg = c;
3891   /* parse configuration */
3892   if (
3893        (GNUNET_OK !=
3894         GNUNET_CONFIGURATION_get_value_number (c,
3895                                                "CORE",
3896                                                "TOTAL_QUOTA_IN",
3897                                                &bandwidth_target_in_bps)) ||
3898        (GNUNET_OK !=
3899         GNUNET_CONFIGURATION_get_value_number (c,
3900                                                "CORE",
3901                                                "TOTAL_QUOTA_OUT",
3902                                                &bandwidth_target_out_bps)) ||
3903        (GNUNET_OK !=
3904         GNUNET_CONFIGURATION_get_value_filename (c,
3905                                                  "GNUNETD",
3906                                                  "HOSTKEY", &keyfile)))
3907     {
3908       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3909                   _
3910                   ("Core service is lacking key configuration settings.  Exiting.\n"));
3911       GNUNET_SCHEDULER_shutdown (s);
3912       return;
3913     }
3914   peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
3915   if (NULL == peerinfo)
3916     {
3917       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3918                   _("Could not access PEERINFO service.  Exiting.\n"));
3919       GNUNET_SCHEDULER_shutdown (s);
3920       GNUNET_free (keyfile);
3921       return;
3922     }
3923   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
3924   GNUNET_free (keyfile);
3925   if (my_private_key == NULL)
3926     {
3927       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3928                   _("Core service could not access hostkey.  Exiting.\n"));
3929       GNUNET_PEERINFO_disconnect (peerinfo);
3930       GNUNET_SCHEDULER_shutdown (s);
3931       return;
3932     }
3933   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
3934   GNUNET_CRYPTO_hash (&my_public_key,
3935                       sizeof (my_public_key), &my_identity.hashPubKey);
3936   /* setup notification */
3937   notifier = GNUNET_SERVER_notification_context_create (server,
3938                                                         MAX_NOTIFY_QUEUE);
3939   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
3940   /* setup transport connection */
3941   transport = GNUNET_TRANSPORT_connect (sched,
3942                                         cfg,
3943                                         &my_identity,
3944                                         NULL,
3945                                         &handle_transport_receive,
3946                                         &handle_transport_notify_connect,
3947                                         &handle_transport_notify_disconnect);
3948   GNUNET_assert (NULL != transport);
3949   stats = GNUNET_STATISTICS_create (sched, "core", cfg);
3950   mst = GNUNET_SERVER_mst_create (&deliver_message,
3951                                   NULL);
3952   GNUNET_SCHEDULER_add_delayed (sched,
3953                                 GNUNET_TIME_UNIT_FOREVER_REL,
3954                                 &cleaning_task, NULL);
3955   /* process client requests */
3956   GNUNET_SERVER_add_handlers (server, handlers);
3957   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3958               _("Core service of `%4s' ready.\n"), GNUNET_i2s (&my_identity));
3959 }
3960
3961
3962
3963 /**
3964  * The main function for the transport service.
3965  *
3966  * @param argc number of arguments from the command line
3967  * @param argv command line arguments
3968  * @return 0 ok, 1 on error
3969  */
3970 int
3971 main (int argc, char *const *argv)
3972 {
3973   return (GNUNET_OK ==
3974           GNUNET_SERVICE_run (argc,
3975                               argv,
3976                               "core",
3977                               GNUNET_SERVICE_OPTION_NONE,
3978                               &run, NULL)) ? 0 : 1;
3979 }
3980
3981 /* end of gnunet-service-core.c */