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