src/core/gnunet-service-core.c

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