src/transport/gnunet-service-transport.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file transport/gnunet-service-transport.c
  23  * @brief low-level P2P messaging
  24  * @author Christian Grothoff
  25  *
  26  */
  27 #include "platform.h"
  28 #include "gnunet_client_lib.h"
  29 #include "gnunet_container_lib.h"
  30 #include "gnunet_constants.h"
  31 #include "gnunet_getopt_lib.h"
  32 #include "gnunet_hello_lib.h"
  33 #include "gnunet_os_lib.h"
  34 #include "gnunet_peerinfo_service.h"
  35 #include "gnunet_plugin_lib.h"
  36 #include "gnunet_protocols.h"
  37 #include "gnunet_service_lib.h"
  38 #include "gnunet_signatures.h"
  39 #include "plugin_transport.h"
  40 #include "transport.h"
  41
  42 #define DEBUG_BLACKLIST GNUNET_YES
  43
  44 #define DEBUG_PING_PONG GNUNET_YES
  45
  46 #define DEBUG_TRANSPORT_HELLO GNUNET_YES
  47
  48 /**
  49  * Should we do some additional checks (to validate behavior
  50  * of clients)?
  51  */
  52 #define EXTRA_CHECKS GNUNET_YES
  53
  54 /**
  55  * How many messages can we have pending for a given client process
  56  * before we start to drop incoming messages?  We typically should
  57  * have only one client and so this would be the primary buffer for
  58   * messages, so the number should be chosen rather generously.
  59  *
  60  * The expectation here is that most of the time the queue is large
  61  * enough so that a drop is virtually never required.  Note that
  62  * this value must be about as large as 'TOTAL_MSGS' in the
  63  * 'test_transport_api_reliability.c', otherwise that testcase may
  64  * fail.
  65  */
  66 #define MAX_PENDING (128 * 1024)
  67
  68 /**
  69  * Size of the per-transport blacklist hash maps.
  70  */
  71 #define TRANSPORT_BLACKLIST_HT_SIZE 16
  72
  73 /**
  74  * How often should we try to reconnect to a peer using a particular
  75  * transport plugin before giving up?  Note that the plugin may be
  76  * added back to the list after PLUGIN_RETRY_FREQUENCY expires.
  77  */
  78 #define MAX_CONNECT_RETRY 3
  79
  80 /**
  81  * Limit on the number of ready-to-run tasks when validating
  82  * HELLOs.  If more tasks are ready to run, we will drop
  83  * HELLOs instead of validating them.
  84  */
  85 #define MAX_HELLO_LOAD 4
  86
  87 /**
  88  * How often must a peer violate bandwidth quotas before we start
  89  * to simply drop its messages?
  90  */
  91 #define QUOTA_VIOLATION_DROP_THRESHOLD 10
  92
  93 /**
  94  * How long until a HELLO verification attempt should time out?
  95  * Must be rather small, otherwise a partially successful HELLO
  96  * validation (some addresses working) might not be available
  97  * before a client's request for a connection fails for good.
  98  * Besides, if a single request to an address takes a long time,
  99  * then the peer is unlikely worthwhile anyway.
 100  */
 101 #define HELLO_VERIFICATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
 102
 103 /**
 104  * How long is a PONG signature valid?  We'll recycle a signature until
 105  * 1/4 of this time is remaining.  PONGs should expire so that if our
 106  * external addresses change an adversary cannot replay them indefinitely.
 107  * OTOH, we don't want to spend too much time generating PONG signatures,
 108  * so they must have some lifetime to reduce our CPU usage.
 109  */
 110 #define PONG_SIGNATURE_LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
 111
 112 /**
 113  * Priority to use for PONG messages.
 114  */
 115 #define TRANSPORT_PONG_PRIORITY 4
 116
 117 /**
 118  * How often do we re-add (cheaper) plugins to our list of plugins
 119  * to try for a given connected peer?
 120  */
 121 #define PLUGIN_RETRY_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 122
 123 /**
 124  * After how long do we expire an address in a HELLO that we just
 125  * validated?  This value is also used for our own addresses when we
 126  * create a HELLO.
 127  */
 128 #define HELLO_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 12)
 129
 130
 131 /**
 132  * How long before an existing address expires should we again try to
 133  * validate it?  Must be (significantly) smaller than
 134  * HELLO_ADDRESS_EXPIRATION.
 135  */
 136 #define HELLO_REVALIDATION_START_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
 137
 138 /**
 139  * Maximum frequency for re-evaluating latencies for all transport addresses.
 140  */
 141 #define LATENCY_EVALUATION_MAX_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
 142
 143 /**
 144  * Maximum frequency for re-evaluating latencies for connected addresses.
 145  */
 146 #define CONNECTED_LATENCY_EVALUATION_MAX_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
 147
 148
 149 /**
 150  * List of addresses of other peers
 151  */
 152 struct ForeignAddressList
 153 {
 154   /**
 155    * This is a linked list.
 156    */
 157   struct ForeignAddressList *next;
 158
 159   /**
 160    * Which ready list does this entry belong to.
 161    */
 162   struct ReadyList *ready_list;
 163
 164   /**
 165    * How long until we auto-expire this address (unless it is
 166    * re-confirmed by the transport)?
 167    */
 168   struct GNUNET_TIME_Absolute expires;
 169
 170   /**
 171    * Task used to re-validate addresses, updates latencies and
 172    * verifies liveness.
 173    */
 174   GNUNET_SCHEDULER_TaskIdentifier revalidate_task;
 175
 176   /**
 177    * The address.
 178    */
 179   const void *addr;
 180
 181   /**
 182    * Session (or NULL if no valid session currently exists or if the
 183    * plugin does not use sessions).
 184    */
 185   struct Session *session;
 186
 187   /**
 188    * What was the last latency observed for this address, plugin and peer?
 189    */
 190   struct GNUNET_TIME_Relative latency;
 191
 192   /**
 193    * If we did not successfully transmit a message to the given peer
 194    * via this connection during the specified time, we should consider
 195    * the connection to be dead.  This is used in the case that a TCP
 196    * transport simply stalls writing to the stream but does not
 197    * formerly get a signal that the other peer died.
 198    */
 199   struct GNUNET_TIME_Absolute timeout;
 200
 201   /**
 202    * How often have we tried to connect using this plugin?  Used to
 203    * discriminate against addresses that do not work well.
 204    * FIXME: not yet used, but should be!
 205    */
 206   unsigned int connect_attempts;
 207
 208   /**
 209    * DV distance to this peer (1 if no DV is used).
 210    * FIXME: need to set this from transport plugins!
 211    */
 212   uint32_t distance;
 213
 214   /**
 215    * Length of addr.
 216    */
 217   uint16_t addrlen;
 218
 219   /**
 220    * Have we ever estimated the latency of this address?  Used to
 221    * ensure that the first time we add an address, we immediately
 222    * probe its latency.
 223    */
 224   int8_t estimated;
 225
 226   /**
 227    * Are we currently connected via this address?  The first time we
 228    * successfully transmit or receive data to a peer via a particular
 229    * address, we set this to GNUNET_YES.  If we later get an error
 230    * (disconnect notification, transmission failure, timeout), we set
 231    * it back to GNUNET_NO.
 232    */
 233   int8_t connected;
 234
 235   /**
 236    * Is this plugin currently busy transmitting to the specific target?
 237    * GNUNET_NO if not (initial, default state is GNUNET_NO).   Internal
 238    * messages do not count as 'in transmit'.
 239    */
 240   int8_t in_transmit;
 241
 242   /**
 243    * Has this address been validated yet?
 244    */
 245   int8_t validated;
 246
 247 };
 248
 249
 250 /**
 251  * Entry in linked list of network addresses for ourselves.  Also
 252  * includes a cached signature for 'struct TransportPongMessage's.
 253  */
 254 struct OwnAddressList
 255 {
 256   /**
 257    * This is a linked list.
 258    */
 259   struct OwnAddressList *next;
 260
 261   /**
 262    * How long until we actually auto-expire this address (unless it is
 263    * re-confirmed by the transport)?
 264    */
 265   struct GNUNET_TIME_Absolute expires;
 266
 267   /**
 268    * How long until the current signature expires? (ZERO if the
 269    * signature was never created).
 270    */
 271   struct GNUNET_TIME_Absolute pong_sig_expires;
 272
 273   /**
 274    * Signature for a 'struct TransportPongMessage' for this address.
 275    */
 276   struct GNUNET_CRYPTO_RsaSignature pong_signature;
 277
 278   /**
 279    * Length of addr.
 280    */
 281   uint32_t addrlen;
 282
 283 };
 284
 285
 286 /**
 287  * Entry in linked list of all of our plugins.
 288  */
 289 struct TransportPlugin
 290 {
 291
 292   /**
 293    * This is a linked list.
 294    */
 295   struct TransportPlugin *next;
 296
 297   /**
 298    * API of the transport as returned by the plugin's
 299    * initialization function.
 300    */
 301   struct GNUNET_TRANSPORT_PluginFunctions *api;
 302
 303   /**
 304    * Short name for the plugin (i.e. "tcp").
 305    */
 306   char *short_name;
 307
 308   /**
 309    * Name of the library (i.e. "gnunet_plugin_transport_tcp").
 310    */
 311   char *lib_name;
 312
 313   /**
 314    * List of our known addresses for this transport.
 315    */
 316   struct OwnAddressList *addresses;
 317
 318   /**
 319    * Environment this transport service is using
 320    * for this plugin.
 321    */
 322   struct GNUNET_TRANSPORT_PluginEnvironment env;
 323
 324   /**
 325    * ID of task that is used to clean up expired addresses.
 326    */
 327   GNUNET_SCHEDULER_TaskIdentifier address_update_task;
 328
 329   /**
 330    * Set to GNUNET_YES if we need to scrap the existing list of
 331    * "addresses" and start fresh when we receive the next address
 332    * update from a transport.  Set to GNUNET_NO if we should just add
 333    * the new address to the list and wait for the commit call.
 334    */
 335   int rebuild;
 336
 337   /**
 338    * Hashmap of blacklisted peers for this particular transport.
 339    */
 340   struct GNUNET_CONTAINER_MultiHashMap *blacklist;
 341 };
 342
 343 struct NeighbourList;
 344
 345 /**
 346  * For each neighbour we keep a list of messages
 347  * that we still want to transmit to the neighbour.
 348  */
 349 struct MessageQueue
 350 {
 351
 352   /**
 353    * This is a doubly linked list.
 354    */
 355   struct MessageQueue *next;
 356
 357   /**
 358    * This is a doubly linked list.
 359    */
 360   struct MessageQueue *prev;
 361
 362   /**
 363    * The message(s) we want to transmit, GNUNET_MessageHeader(s)
 364    * stuck together in memory.  Allocated at the end of this struct.
 365    */
 366   const char *message_buf;
 367
 368   /**
 369    * Size of the message buf
 370    */
 371   size_t message_buf_size;
 372
 373   /**
 374    * Client responsible for queueing the message;
 375    * used to check that a client has no two messages
 376    * pending for the same target.  Can be NULL.
 377    */
 378   struct TransportClient *client;
 379
 380   /**
 381    * Using which specific address should we send this message?
 382    */
 383   struct ForeignAddressList *specific_address;
 384
 385   /**
 386    * Peer ID of the Neighbour this entry belongs to.
 387    */
 388   struct GNUNET_PeerIdentity neighbour_id;
 389
 390   /**
 391    * Plugin that we used for the transmission.
 392    * NULL until we scheduled a transmission.
 393    */
 394   struct TransportPlugin *plugin;
 395
 396   /**
 397    * At what time should we fail?
 398    */
 399   struct GNUNET_TIME_Absolute timeout;
 400
 401   /**
 402    * Internal message of the transport system that should not be
 403    * included in the usual SEND-SEND_OK transmission confirmation
 404    * traffic management scheme.  Typically, "internal_msg" will
 405    * be set whenever "client" is NULL (but it is not strictly
 406    * required).
 407    */
 408   int internal_msg;
 409
 410   /**
 411    * How important is the message?
 412    */
 413   unsigned int priority;
 414
 415 };
 416
 417
 418 /**
 419  * For a given Neighbour, which plugins are available
 420  * to talk to this peer and what are their costs?
 421  */
 422 struct ReadyList
 423 {
 424   /**
 425    * This is a linked list.
 426    */
 427   struct ReadyList *next;
 428
 429   /**
 430    * Which of our transport plugins does this entry
 431    * represent?
 432    */
 433   struct TransportPlugin *plugin;
 434
 435   /**
 436    * Transport addresses, latency, and readiness for
 437    * this particular plugin.
 438    */
 439   struct ForeignAddressList *addresses;
 440
 441   /**
 442    * To which neighbour does this ready list belong to?
 443    */
 444   struct NeighbourList *neighbour;
 445
 446 };
 447
 448
 449 /**
 450  * Entry in linked list of all of our current neighbours.
 451  */
 452 struct NeighbourList
 453 {
 454
 455   /**
 456    * This is a linked list.
 457    */
 458   struct NeighbourList *next;
 459
 460   /**
 461    * Which of our transports is connected to this peer
 462    * and what is their status?
 463    */
 464   struct ReadyList *plugins;
 465
 466   /**
 467    * Head of list of messages we would like to send to this peer;
 468    * must contain at most one message per client.
 469    */
 470   struct MessageQueue *messages_head;
 471
 472   /**
 473    * Tail of list of messages we would like to send to this peer; must
 474    * contain at most one message per client.
 475    */
 476   struct MessageQueue *messages_tail;
 477
 478   /**
 479    * Buffer for at most one payload message used when we receive
 480    * payload data before our PING-PONG has succeeded.  We then
 481    * store such messages in this intermediary buffer until the
 482    * connection is fully up.
 483    */
 484   struct GNUNET_MessageHeader *pre_connect_message_buffer;
 485
 486   /**
 487    * Context for peerinfo iteration.
 488    * NULL after we are done processing peerinfo's information.
 489    */
 490   struct GNUNET_PEERINFO_IteratorContext *piter;
 491
 492   /**
 493    * Public key for this peer.   Valid only if the respective flag is set below.
 494    */
 495   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
 496
 497   /**
 498    * Identity of this neighbour.
 499    */
 500   struct GNUNET_PeerIdentity id;
 501
 502   /**
 503    * ID of task scheduled to run when this peer is about to
 504    * time out (will free resources associated with the peer).
 505    */
 506   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 507
 508   /**
 509    * ID of task scheduled to run when we should retry transmitting
 510    * the head of the message queue.  Actually triggered when the
 511    * transmission is timing out (we trigger instantly when we have
 512    * a chance of success).
 513    */
 514   GNUNET_SCHEDULER_TaskIdentifier retry_task;
 515
 516   /**
 517    * How long until we should consider this peer dead
 518    * (if we don't receive another message in the
 519    * meantime)?
 520    */
 521   struct GNUNET_TIME_Absolute peer_timeout;
 522
 523   /**
 524    * Tracker for inbound bandwidth.
 525    */
 526   struct GNUNET_BANDWIDTH_Tracker in_tracker;
 527
 528   /**
 529    * The latency we have seen for this particular address for
 530    * this particular peer.  This latency may have been calculated
 531    * over multiple transports.  This value reflects how long it took
 532    * us to receive a response when SENDING via this particular
 533    * transport/neighbour/address combination!
 534    *
 535    * FIXME: we need to periodically send PINGs to update this
 536    * latency (at least more often than the current "huge" (11h?)
 537    * update interval).
 538    */
 539   struct GNUNET_TIME_Relative latency;
 540
 541   /**
 542    * How often has the other peer (recently) violated the
 543    * inbound traffic limit?  Incremented by 10 per violation,
 544    * decremented by 1 per non-violation (for each
 545    * time interval).
 546    */
 547   unsigned int quota_violation_count;
 548
 549   /**
 550    * DV distance to this peer (1 if no DV is used).
 551    */
 552   uint32_t distance;
 553
 554   /**
 555    * Have we seen an PONG from this neighbour in the past (and
 556    * not had a disconnect since)?
 557    */
 558   int received_pong;
 559
 560   /**
 561    * Do we have a valid public key for this neighbour?
 562    */
 563   int public_key_valid;
 564
 565 };
 566
 567 /**
 568  * Message used to ask a peer to validate receipt (to check an address
 569  * from a HELLO).  Followed by the address we are trying to validate,
 570  * or an empty address if we are just sending a PING to confirm that a
 571  * connection which the receiver (of the PING) initiated is still valid.
 572  */
 573 struct TransportPingMessage
 574 {
 575
 576   /**
 577    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PING
 578    */
 579   struct GNUNET_MessageHeader header;
 580
 581   /**
 582    * Challenge code (to ensure fresh reply).
 583    */
 584   uint32_t challenge GNUNET_PACKED;
 585
 586   /**
 587    * Who is the intended recipient?
 588    */
 589   struct GNUNET_PeerIdentity target;
 590
 591 };
 592
 593
 594 /**
 595  * Message used to validate a HELLO.  The challenge is included in the
 596  * confirmation to make matching of replies to requests possible.  The
 597  * signature signs our public key, an expiration time and our address.<p>
 598  *
 599  * This message is followed by our transport address that the PING tried
 600  * to confirm (if we liked it).  The address can be empty (zero bytes)
 601  * if the PING had not address either (and we received the request via
 602  * a connection that we initiated).
 603  */
 604 struct TransportPongMessage
 605 {
 606
 607   /**
 608    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PONG
 609    */
 610   struct GNUNET_MessageHeader header;
 611
 612   /**
 613    * Challenge code from PING (showing freshness).  Not part of what
 614    * is signed so that we can re-use signatures.
 615    */
 616   uint32_t challenge GNUNET_PACKED;
 617
 618   /**
 619    * Signature.
 620    */
 621   struct GNUNET_CRYPTO_RsaSignature signature;
 622
 623   /**
 624    * What are we signing and why?  Two possible reason codes can be here:
 625    * GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN to confirm that this is a
 626    * plausible address for this peer (pid is set to identity of signer); or
 627    * GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING to confirm that this is
 628    * an address we used to connect to the peer with the given pid.
 629    */
 630   struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
 631
 632   /**
 633    * When does this signature expire?
 634    */
 635   struct GNUNET_TIME_AbsoluteNBO expiration;
 636
 637   /**
 638    * Either the identity of the peer Who signed this message, or the
 639    * identity of the peer that we're connected to using the given
 640    * address (depending on purpose.type).
 641    */
 642   struct GNUNET_PeerIdentity pid;
 643
 644   /**
 645    * Size of address appended to this message (part of what is
 646    * being signed, hence not redundant).
 647    */
 648   uint32_t addrlen;
 649
 650 };
 651
 652
 653 /**
 654  * Linked list of messages to be transmitted to the client.  Each
 655  * entry is followed by the actual message.
 656  */
 657 struct ClientMessageQueueEntry
 658 {
 659   /**
 660    * This is a doubly-linked list.
 661    */
 662   struct ClientMessageQueueEntry *next;
 663
 664   /**
 665    * This is a doubly-linked list.
 666    */
 667   struct ClientMessageQueueEntry *prev;
 668 };
 669
 670
 671 /**
 672  * Client connected to the transport service.
 673  */
 674 struct TransportClient
 675 {
 676
 677   /**
 678    * This is a linked list.
 679    */
 680   struct TransportClient *next;
 681
 682   /**
 683    * Handle to the client.
 684    */
 685   struct GNUNET_SERVER_Client *client;
 686
 687   /**
 688    * Linked list of messages yet to be transmitted to
 689    * the client.
 690    */
 691   struct ClientMessageQueueEntry *message_queue_head;
 692
 693   /**
 694    * Tail of linked list of messages yet to be transmitted to the
 695    * client.
 696    */
 697   struct ClientMessageQueueEntry *message_queue_tail;
 698
 699   /**
 700    * Current transmit request handle.
 701    */
 702   struct GNUNET_CONNECTION_TransmitHandle *th;
 703
 704   /**
 705    * Is a call to "transmit_send_continuation" pending?  If so, we
 706    * must not free this struct (even if the corresponding client
 707    * disconnects) and instead only remove it from the linked list and
 708    * set the "client" field to NULL.
 709    */
 710   int tcs_pending;
 711
 712   /**
 713    * Length of the list of messages pending for this client.
 714    */
 715   unsigned int message_count;
 716
 717 };
 718
 719
 720 /**
 721  * Context of currently active requests to peerinfo
 722  * for validation of HELLOs.
 723  */
 724 struct CheckHelloValidatedContext;
 725
 726
 727 /**
 728  * Entry in map of all HELLOs awaiting validation.
 729  */
 730 struct ValidationEntry
 731 {
 732
 733   /**
 734    * NULL if this entry is not part of a larger HELLO validation.
 735    */
 736   struct CheckHelloValidatedContext *chvc;
 737
 738   /**
 739    * The address, actually a pointer to the end
 740    * of this struct.  Do not free!
 741    */
 742   const void *addr;
 743
 744   /**
 745    * Name of the transport.
 746    */
 747   char *transport_name;
 748
 749   /**
 750    * The public key of the peer.
 751    */
 752   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
 753
 754   /**
 755    * ID of task that will clean up this entry if we don't succeed
 756    * with the validation first.
 757    */
 758   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 759
 760   /**
 761    * At what time did we send this validation?
 762    */
 763   struct GNUNET_TIME_Absolute send_time;
 764
 765   /**
 766    * Session being validated (or NULL for none).
 767    */
 768   struct Session *session;
 769
 770   /**
 771    * Challenge number we used.
 772    */
 773   uint32_t challenge;
 774
 775   /**
 776    * Length of addr.
 777    */
 778   uint16_t addrlen;
 779
 780 };
 781
 782
 783 /**
 784  * Context of currently active requests to peerinfo
 785  * for validation of HELLOs.
 786  */
 787 struct CheckHelloValidatedContext
 788 {
 789
 790   /**
 791    * This is a doubly-linked list.
 792    */
 793   struct CheckHelloValidatedContext *next;
 794
 795   /**
 796    * This is a doubly-linked list.
 797    */
 798   struct CheckHelloValidatedContext *prev;
 799
 800   /**
 801    * Hello that we are validating.
 802    */
 803   const struct GNUNET_HELLO_Message *hello;
 804
 805   /**
 806    * Context for peerinfo iteration.
 807    * NULL after we are done processing peerinfo's information.
 808    */
 809   struct GNUNET_PEERINFO_IteratorContext *piter;
 810
 811   /**
 812    * Was a HELLO known for this peer to peerinfo?
 813    */
 814   int hello_known;
 815
 816   /**
 817    * Number of validation entries currently referring to this
 818    * CHVC.
 819    */
 820   unsigned int ve_count;
 821 };
 822
 823
 824
 825 /**
 826  * Our HELLO message.
 827  */
 828 static struct GNUNET_HELLO_Message *our_hello;
 829
 830 /**
 831  * Our public key.
 832  */
 833 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
 834
 835 /**
 836  * Our identity.
 837  */
 838 static struct GNUNET_PeerIdentity my_identity;
 839
 840 /**
 841  * Our private key.
 842  */
 843 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
 844
 845 /**
 846  * Our scheduler.
 847  */
 848 struct GNUNET_SCHEDULER_Handle *sched;
 849
 850 /**
 851  * Our configuration.
 852  */
 853 const struct GNUNET_CONFIGURATION_Handle *cfg;
 854
 855 /**
 856  * Linked list of all clients to this service.
 857  */
 858 static struct TransportClient *clients;
 859
 860 /**
 861  * All loaded plugins.
 862  */
 863 static struct TransportPlugin *plugins;
 864
 865 /**
 866  * Handle to peerinfo service.
 867  */
 868 static struct GNUNET_PEERINFO_Handle *peerinfo;
 869
 870 /**
 871  * All known neighbours and their HELLOs.
 872  */
 873 static struct NeighbourList *neighbours;
 874
 875 /**
 876  * Number of neighbours we'd like to have.
 877  */
 878 static uint32_t max_connect_per_transport;
 879
 880 /**
 881  * Head of linked list.
 882  */
 883 static struct CheckHelloValidatedContext *chvc_head;
 884
 885 /**
 886  * Tail of linked list.
 887  */
 888 static struct CheckHelloValidatedContext *chvc_tail;
 889
 890 /**
 891  * Map of PeerIdentities to 'struct ValidationEntry*'s (addresses
 892  * of the given peer that we are currently validating).
 893  */
 894 static struct GNUNET_CONTAINER_MultiHashMap *validation_map;
 895
 896 /**
 897  * Handle for reporting statistics.
 898  */
 899 static struct GNUNET_STATISTICS_Handle *stats;
 900
 901 /**
 902  * The peer specified by the given neighbour has timed-out or a plugin
 903  * has disconnected.  We may either need to do nothing (other plugins
 904  * still up), or trigger a full disconnect and clean up.  This
 905  * function updates our state and do the necessary notifications.
 906  * Also notifies our clients that the neighbour is now officially
 907  * gone.
 908  *
 909  * @param n the neighbour list entry for the peer
 910  * @param check should we just check if all plugins
 911  *        disconnected or must we ask all plugins to
 912  *        disconnect?
 913  */
 914 static void disconnect_neighbour (struct NeighbourList *n, int check);
 915
 916 /**
 917  * Check the ready list for the given neighbour and if a plugin is
 918  * ready for transmission (and if we have a message), do so!
 919  *
 920  * @param neighbour target peer for which to transmit
 921  */
 922 static void try_transmission_to_peer (struct NeighbourList *neighbour);
 923
 924
 925 /**
 926  * Find an entry in the neighbour list for a particular peer.
 927  *
 928  * @return NULL if not found.
 929  */
 930 static struct NeighbourList *
 931 find_neighbour (const struct GNUNET_PeerIdentity *key)
 932 {
 933   struct NeighbourList *head = neighbours;
 934
 935   while ((head != NULL) &&
 936         (0 != memcmp (key, &head->id, sizeof (struct GNUNET_PeerIdentity))))
 937     head = head->next;
 938   return head;
 939 }
 940
 941
 942 /**
 943  * Find an entry in the transport list for a particular transport.
 944  *
 945  * @return NULL if not found.
 946  */
 947 static struct TransportPlugin *
 948 find_transport (const char *short_name)
 949 {
 950   struct TransportPlugin *head = plugins;
 951   while ((head != NULL) && (0 != strcmp (short_name, head->short_name)))
 952     head = head->next;
 953   return head;
 954 }
 955
 956 /**
 957  * Is a particular peer blacklisted for a particular transport?
 958  *
 959  * @param peer the peer to check for
 960  * @param plugin the plugin used to connect to the peer
 961  *
 962  * @return GNUNET_YES if the peer is blacklisted, GNUNET_NO if not
 963  */
 964 static int
 965 is_blacklisted (const struct GNUNET_PeerIdentity *peer, struct TransportPlugin *plugin)
 966 {
 967
 968   if (plugin->blacklist != NULL)
 969     {
 970       if (GNUNET_CONTAINER_multihashmap_contains(plugin->blacklist, &peer->hashPubKey) == GNUNET_YES)
 971         {
 972 #if DEBUG_BLACKLIST
 973           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 974                       _("Peer `%s:%s' is blacklisted!\n"),
 975                       plugin->short_name, GNUNET_i2s (peer));
 976 #endif
 977           return GNUNET_YES;
 978         }
 979     }
 980
 981   return GNUNET_NO;
 982 }
 983
 984
 985 static void
 986 add_peer_to_blacklist (struct GNUNET_PeerIdentity *peer, char *transport_name)
 987 {
 988   struct TransportPlugin *plugin;
 989
 990   plugin = find_transport(transport_name);
 991   if (plugin == NULL) /* Nothing to do */
 992     return;
 993   if (plugin->blacklist == NULL)
 994     plugin->blacklist = GNUNET_CONTAINER_multihashmap_create(TRANSPORT_BLACKLIST_HT_SIZE);
 995   GNUNET_assert(plugin->blacklist != NULL);
 996   GNUNET_CONTAINER_multihashmap_put(plugin->blacklist, &peer->hashPubKey,
 997                                     NULL,
 998                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
 999 }
1000
1001
1002 /**
1003  * Read the blacklist file, containing transport:peer entries.
1004  * Provided the transport is loaded, set up hashmap with these
1005  * entries to blacklist peers by transport.
1006  *
1007  */
1008 static void
1009 read_blacklist_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
1010 {
1011   char *fn;
1012   char *data;
1013   size_t pos;
1014   size_t colon_pos;
1015   int tsize;
1016   struct GNUNET_PeerIdentity pid;
1017   struct stat frstat;
1018   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
1019   unsigned int entries_found;
1020   char *transport_name;
1021
1022   if (GNUNET_OK !=
1023       GNUNET_CONFIGURATION_get_value_filename (cfg,
1024                                                "TRANSPORT",
1025                                                "BLACKLIST_FILE",
1026                                                &fn))
1027     {
1028 #if DEBUG_TRANSPORT
1029       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1030                   _("Option `%s' in section `%s' not specified!\n"),
1031                   "BLACKLIST_FILE",
1032                   "TRANSPORT");
1033 #endif
1034       return;
1035     }
1036   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
1037     GNUNET_DISK_fn_write (fn, NULL, 0, GNUNET_DISK_PERM_USER_READ
1038         | GNUNET_DISK_PERM_USER_WRITE);
1039   if (0 != STAT (fn, &frstat))
1040     {
1041       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1042                   _("Could not read blacklist file `%s'\n"), fn);
1043       GNUNET_free (fn);
1044       return;
1045     }
1046   if (frstat.st_size == 0)
1047     {
1048 #if DEBUG_TRANSPORT
1049       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1050                   _("Blacklist file `%s' is empty.\n"),
1051                   fn);
1052 #endif
1053       GNUNET_free (fn);
1054       return;
1055     }
1056   /* FIXME: use mmap */
1057   data = GNUNET_malloc_large (frstat.st_size);
1058   GNUNET_assert(data != NULL);
1059   if (frstat.st_size !=
1060       GNUNET_DISK_fn_read (fn, data, frstat.st_size))
1061     {
1062       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1063                   _("Failed to read blacklist from `%s'\n"), fn);
1064       GNUNET_free (fn);
1065       GNUNET_free (data);
1066       return;
1067     }
1068   entries_found = 0;
1069   pos = 0;
1070   while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
1071     pos++;
1072   while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
1073          (pos <= frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
1074     {
1075       colon_pos = pos;
1076       while ((colon_pos < frstat.st_size) && (data[colon_pos] != ':') && !isspace ( (unsigned char) data[colon_pos]))
1077         colon_pos++;
1078
1079       if (colon_pos >= frstat.st_size)
1080         {
1081           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1082                       _("Syntax error in blacklist file at offset %llu, giving up!\n"),
1083                       (unsigned long long) colon_pos);
1084           GNUNET_free (fn);
1085           GNUNET_free (data);
1086           return;
1087         }
1088
1089       if (isspace( (unsigned char) data[colon_pos]))
1090       {
1091         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1092                     _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
1093                     (unsigned long long) colon_pos);
1094         pos = colon_pos;
1095         while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
1096           pos++;
1097         continue;
1098       }
1099       tsize = colon_pos - pos;
1100       if ((pos >= frstat.st_size) || (pos + tsize >= frstat.st_size) || (tsize == 0))
1101         {
1102           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1103                       _("Syntax error in blacklist file at offset %llu, giving up!\n"),
1104                       (unsigned long long) colon_pos);
1105           GNUNET_free (fn);
1106           GNUNET_free (data);
1107           return;
1108         }
1109
1110       if (tsize < 1)
1111         continue;
1112
1113       transport_name = GNUNET_malloc(tsize + 1);
1114       memcpy(transport_name, &data[pos], tsize);
1115       pos = colon_pos + 1;
1116 #if DEBUG_TRANSPORT
1117       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1118                   _("Read transport name %s in blacklist file.\n"),
1119                   transport_name);
1120 #endif
1121       memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
1122       if (!isspace ( (unsigned char) enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
1123         {
1124           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1125                       _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
1126                       (unsigned long long) pos);
1127           pos++;
1128           while ((pos < frstat.st_size) && (!isspace ( (unsigned char) data[pos])))
1129             pos++;
1130           GNUNET_free_non_null(transport_name);
1131           continue;
1132         }
1133       enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
1134       if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
1135         {
1136           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1137                       _("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
1138                       (unsigned long long) pos,
1139                       &enc);
1140         }
1141       else
1142         {
1143           if (0 != memcmp (&pid,
1144                            &my_identity,
1145                            sizeof (struct GNUNET_PeerIdentity)))
1146             {
1147               entries_found++;
1148               add_peer_to_blacklist (&pid,
1149                                      transport_name);
1150             }
1151           else
1152             {
1153               GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1154                           _("Found myself `%s' in blacklist (useless, ignored)\n"),
1155                           GNUNET_i2s (&pid));
1156             }
1157         }
1158       pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
1159       GNUNET_free_non_null(transport_name);
1160       while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
1161         pos++;
1162     }
1163   GNUNET_free (data);
1164   GNUNET_free (fn);
1165 }
1166
1167
1168 /**
1169  * Function called to notify a client about the socket being ready to
1170  * queue more data.  "buf" will be NULL and "size" zero if the socket
1171  * was closed for writing in the meantime.
1172  *
1173  * @param cls closure
1174  * @param size number of bytes available in buf
1175  * @param buf where the callee should write the message
1176  * @return number of bytes written to buf
1177  */
1178 static size_t
1179 transmit_to_client_callback (void *cls, size_t size, void *buf)
1180 {
1181   struct TransportClient *client = cls;
1182   struct ClientMessageQueueEntry *q;
1183   uint16_t msize;
1184   size_t tsize;
1185   const struct GNUNET_MessageHeader *msg;
1186   char *cbuf;
1187
1188   client->th = NULL;
1189   if (buf == NULL)
1190     {
1191       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1192                   "Transmission to client failed, closing connection.\n");
1193       /* fatal error with client, free message queue! */
1194       while (NULL != (q = client->message_queue_head))
1195         {
1196           GNUNET_STATISTICS_update (stats,
1197                                     gettext_noop ("# bytes discarded (could not transmit to client)"),
1198                                     ntohs (((const struct GNUNET_MessageHeader*)&q[1])->size),
1199                                     GNUNET_NO);
1200           GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
1201                                        client->message_queue_tail,
1202                                        q);
1203           GNUNET_free (q);
1204         }
1205       client->message_count = 0;
1206       return 0;
1207     }
1208   cbuf = buf;
1209   tsize = 0;
1210   while (NULL != (q = client->message_queue_head))
1211     {
1212       msg = (const struct GNUNET_MessageHeader *) &q[1];
1213       msize = ntohs (msg->size);
1214       if (msize + tsize > size)
1215         break;
1216 #if DEBUG_TRANSPORT
1217       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1218                   "Transmitting message of type %u to client.\n",
1219                   ntohs (msg->type));
1220 #endif
1221       GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
1222                                    client->message_queue_tail,
1223                                    q);
1224       memcpy (&cbuf[tsize], msg, msize);
1225       tsize += msize;
1226       GNUNET_free (q);
1227       client->message_count--;
1228     }
1229   if (NULL != q)
1230     {
1231       GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
1232       client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
1233                                                         msize,
1234                                                         GNUNET_TIME_UNIT_FOREVER_REL,
1235                                                         &transmit_to_client_callback,
1236                                                         client);
1237       GNUNET_assert (client->th != NULL);
1238     }
1239   return tsize;
1240 }
1241
1242
1243 /**
1244  * Convert an address to a string.
1245  *
1246  * @param plugin name of the plugin responsible for the address
1247  * @param addr binary address
1248  * @param addr_len number of bytes in addr
1249  * @return NULL on error, otherwise address string
1250  */
1251 static const char*
1252 a2s (const char *plugin,
1253      const void *addr,
1254      uint16_t addr_len)
1255 {
1256   struct TransportPlugin *p;
1257
1258   if (plugin == NULL)
1259     return NULL;
1260   p = find_transport (plugin);
1261   if (p == NULL)
1262     return NULL;
1263   return p->api->address_to_string (p->api->cls,
1264                                     addr,
1265                                     addr_len);
1266 }
1267
1268
1269 /**
1270  * Mark the given FAL entry as 'connected' (and hence preferred for
1271  * sending); also mark all others for the same peer as 'not connected'
1272  * (since only one can be preferred).
1273  *
1274  * @param fal address to set to 'connected'
1275  */
1276 static void
1277 mark_address_connected (struct ForeignAddressList *fal)
1278 {
1279   struct ForeignAddressList *pos;
1280   int cnt;
1281
1282   GNUNET_assert (GNUNET_YES == fal->validated);
1283   if (fal->connected == GNUNET_YES)
1284     return; /* nothing to do */
1285   cnt = GNUNET_YES;
1286   pos = fal->ready_list->addresses;
1287   while (pos != NULL)
1288     {
1289       if (GNUNET_YES == pos->connected)
1290         {
1291 #if DEBUG_TRANSPORT
1292           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1293                       "Marking address `%s' as no longer connected (due to connect on other address)\n",
1294                       a2s (pos->ready_list->plugin->short_name,
1295                            pos->addr,
1296                            pos->addrlen));
1297 #endif
1298           GNUNET_break (cnt == GNUNET_YES);
1299           cnt = GNUNET_NO;
1300           pos->connected = GNUNET_NO;
1301           GNUNET_STATISTICS_update (stats,
1302                                     gettext_noop ("# connected addresses"),
1303                                     -1,
1304                                     GNUNET_NO);
1305         }
1306       pos = pos->next;
1307     }
1308   fal->connected = GNUNET_YES;
1309   if (GNUNET_YES == cnt)
1310     {
1311       GNUNET_STATISTICS_update (stats,
1312                                 gettext_noop ("# connected addresses"),
1313                                 1,
1314                                 GNUNET_NO);
1315     }
1316 }
1317
1318
1319 /**
1320  * Send the specified message to the specified client.  Since multiple
1321  * messages may be pending for the same client at a time, this code
1322  * makes sure that no message is lost.
1323  *
1324  * @param client client to transmit the message to
1325  * @param msg the message to send
1326  * @param may_drop can this message be dropped if the
1327  *        message queue for this client is getting far too large?
1328  */
1329 static void
1330 transmit_to_client (struct TransportClient *client,
1331                     const struct GNUNET_MessageHeader *msg, int may_drop)
1332 {
1333   struct ClientMessageQueueEntry *q;
1334   uint16_t msize;
1335
1336   if ((client->message_count >= MAX_PENDING) && (GNUNET_YES == may_drop))
1337     {
1338       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1339                   _
1340                   ("Dropping message of type %u and size %u, have %u messages pending (%u is the soft limit)\n"),
1341                   ntohs (msg->type),
1342                   ntohs (msg->size),
1343                   client->message_count,
1344                   MAX_PENDING);
1345       GNUNET_STATISTICS_update (stats,
1346                                 gettext_noop ("# messages dropped due to slow client"),
1347                                 1,
1348                                 GNUNET_NO);
1349       return;
1350     }
1351   msize = ntohs (msg->size);
1352   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
1353   q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize);
1354   memcpy (&q[1], msg, msize);
1355   GNUNET_CONTAINER_DLL_insert_after (client->message_queue_head,
1356                                      client->message_queue_tail,
1357                                      client->message_queue_tail,
1358                                      q);
1359   client->message_count++;
1360   if (client->th == NULL)
1361     {
1362       client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
1363                                                         msize,
1364                                                         GNUNET_TIME_UNIT_FOREVER_REL,
1365                                                         &transmit_to_client_callback,
1366                                                         client);
1367       GNUNET_assert (client->th != NULL);
1368     }
1369 }
1370
1371
1372 /**
1373  * Transmit a 'SEND_OK' notification to the given client for the
1374  * given neighbour.
1375  *
1376  * @param client who to notify
1377  * @param n neighbour to notify about
1378  * @param result status code for the transmission request
1379  */
1380 static void
1381 transmit_send_ok (struct TransportClient *client,
1382                   struct NeighbourList *n,
1383                   int result)
1384 {
1385   struct SendOkMessage send_ok_msg;
1386
1387   send_ok_msg.header.size = htons (sizeof (send_ok_msg));
1388   send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
1389   send_ok_msg.success = htonl (result);
1390   send_ok_msg.latency = GNUNET_TIME_relative_hton (n->latency);
1391   send_ok_msg.peer = n->id;
1392   transmit_to_client (client, &send_ok_msg.header, GNUNET_NO);
1393 }
1394
1395
1396 /**
1397  * Function called by the GNUNET_TRANSPORT_TransmitFunction
1398  * upon "completion" of a send request.  This tells the API
1399  * that it is now legal to send another message to the given
1400  * peer.
1401  *
1402  * @param cls closure, identifies the entry on the
1403  *            message queue that was transmitted and the
1404  *            client responsible for queueing the message
1405  * @param target the peer receiving the message
1406  * @param result GNUNET_OK on success, if the transmission
1407  *           failed, we should not tell the client to transmit
1408  *           more messages
1409  */
1410 static void
1411 transmit_send_continuation (void *cls,
1412                             const struct GNUNET_PeerIdentity *target,
1413                             int result)
1414 {
1415   struct MessageQueue *mq = cls;
1416   struct NeighbourList *n;
1417
1418   GNUNET_STATISTICS_update (stats,
1419                             gettext_noop ("# bytes pending with plugins"),
1420                             - (int64_t) mq->message_buf_size,
1421                             GNUNET_NO);
1422   if (result == GNUNET_OK)
1423     {
1424       GNUNET_STATISTICS_update (stats,
1425                                 gettext_noop ("# bytes successfully transmitted by plugins"),
1426                                 mq->message_buf_size,
1427                                 GNUNET_NO);
1428     }
1429   else
1430     {
1431       GNUNET_STATISTICS_update (stats,
1432                                 gettext_noop ("# bytes with transmission failure by plugins"),
1433                                 mq->message_buf_size,
1434                                 GNUNET_NO);
1435     }
1436   n = find_neighbour(&mq->neighbour_id);
1437   GNUNET_assert (n != NULL);
1438   if (mq->specific_address != NULL)
1439     {
1440       if (result == GNUNET_OK)
1441         {
1442           mq->specific_address->timeout =
1443             GNUNET_TIME_relative_to_absolute
1444             (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
1445           if (mq->specific_address->validated == GNUNET_YES)
1446             mark_address_connected (mq->specific_address);
1447         }
1448       else
1449         {
1450           if (mq->specific_address->connected != GNUNET_NO)
1451             {
1452 #if DEBUG_TRANSPORT
1453               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1454                           "Marking address `%s' as no longer connected (due to transmission problem)\n",
1455                           a2s (mq->specific_address->ready_list->plugin->short_name,
1456                                mq->specific_address->addr,
1457                                mq->specific_address->addrlen));
1458 #endif
1459               GNUNET_STATISTICS_update (stats,
1460                                         gettext_noop ("# connected addresses"),
1461                                         -1,
1462                                         GNUNET_NO);
1463               mq->specific_address->connected = GNUNET_NO;
1464             }
1465         }
1466       if (! mq->internal_msg)
1467         mq->specific_address->in_transmit = GNUNET_NO;
1468     }
1469   if (mq->client != NULL)
1470     transmit_send_ok (mq->client, n, result);
1471   GNUNET_free (mq);
1472   try_transmission_to_peer (n);
1473 }
1474
1475
1476 /**
1477  * Find an address in any of the available transports for
1478  * the given neighbour that would be good for message
1479  * transmission.  This is essentially the transport selection
1480  * routine.
1481  *
1482  * @param neighbour for whom to select an address
1483  * @return selected address, NULL if we have none
1484  */
1485 struct ForeignAddressList *
1486 find_ready_address(struct NeighbourList *neighbour)
1487 {
1488   struct ReadyList *head = neighbour->plugins;
1489   struct ForeignAddressList *addresses;
1490   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
1491   struct ForeignAddressList *best_address;
1492
1493   best_address = NULL;
1494   while (head != NULL)
1495     {
1496       addresses = head->addresses;
1497       while (addresses != NULL)
1498         {
1499           if ( (addresses->timeout.abs_value < now.abs_value) &&
1500                (addresses->connected == GNUNET_YES) )
1501             {
1502 #if DEBUG_TRANSPORT
1503               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1504                           "Marking long-time inactive connection to `%4s' as down.\n",
1505                           GNUNET_i2s (&neighbour->id));
1506 #endif
1507               GNUNET_STATISTICS_update (stats,
1508                                         gettext_noop ("# connected addresses"),
1509                                         -1,
1510                                         GNUNET_NO);
1511               addresses->connected = GNUNET_NO;
1512             }
1513           addresses = addresses->next;
1514         }
1515
1516       addresses = head->addresses;
1517       while (addresses != NULL)
1518         {
1519 #if DEBUG_TRANSPORT > 1
1520           if (addresses->addr != NULL)
1521             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1522                         "Have address `%s' for peer `%4s' (status: %d, %d, %d, %u, %llums, %u)\n",
1523                         a2s (head->plugin->short_name,
1524                              addresses->addr,
1525                              addresses->addrlen),
1526                         GNUNET_i2s (&neighbour->id),
1527                         addresses->connected,
1528                         addresses->in_transmit,
1529                         addresses->validated,
1530                         addresses->connect_attempts,
1531                         (unsigned long long) addresses->timeout.abs_value,
1532                         (unsigned int) addresses->distance);
1533 #endif
1534           if ( ( (best_address == NULL) ||
1535                  (addresses->connected == GNUNET_YES) ||
1536                  (best_address->connected == GNUNET_NO) ) &&
1537                (addresses->in_transmit == GNUNET_NO) &&
1538                ( (best_address == NULL) ||
1539                  (addresses->latency.rel_value < best_address->latency.rel_value)) )
1540             best_address = addresses;
1541           /* FIXME: also give lower-latency addresses that are not
1542              connected a chance some times... */
1543           addresses = addresses->next;
1544         }
1545       head = head->next;
1546     }
1547   if (best_address != NULL)
1548     {
1549 #if DEBUG_TRANSPORT
1550       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1551                   "Best address found (`%s') has latency of %llu ms.\n",
1552                   (best_address->addrlen > 0)
1553                   ? a2s (best_address->ready_list->plugin->short_name,
1554                        best_address->addr,
1555                        best_address->addrlen)
1556                   : "<inbound>",
1557                   best_address->latency.rel_value);
1558 #endif
1559     }
1560   else
1561     {
1562       GNUNET_STATISTICS_update (stats,
1563                                 gettext_noop ("# transmission attempts failed (no address)"),
1564                                 1,
1565                                 GNUNET_NO);
1566     }
1567   return best_address;
1568
1569 }
1570
1571
1572 /**
1573  * We should re-try transmitting to the given peer,
1574  * hopefully we've learned something in the meantime.
1575  */
1576 static void
1577 retry_transmission_task (void *cls,
1578                          const struct GNUNET_SCHEDULER_TaskContext *tc)
1579 {
1580   struct NeighbourList *n = cls;
1581
1582   n->retry_task = GNUNET_SCHEDULER_NO_TASK;
1583   try_transmission_to_peer (n);
1584 }
1585
1586
1587 /**
1588  * Check the ready list for the given neighbour and if a plugin is
1589  * ready for transmission (and if we have a message), do so!
1590  *
1591  * @param neighbour target peer for which to transmit
1592  */
1593 static void
1594 try_transmission_to_peer (struct NeighbourList *neighbour)
1595 {
1596   struct ReadyList *rl;
1597   struct MessageQueue *mq;
1598   struct GNUNET_TIME_Relative timeout;
1599   ssize_t ret;
1600   int force_address;
1601
1602   if (neighbour->messages_head == NULL)
1603     {
1604 #if DEBUG_TRANSPORT
1605       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1606                   "Transmission queue for `%4s' is empty\n",
1607                   GNUNET_i2s (&neighbour->id));
1608 #endif
1609       return;                     /* nothing to do */
1610     }
1611   rl = NULL;
1612   mq = neighbour->messages_head;
1613   force_address = GNUNET_YES;
1614   if (mq->specific_address == NULL)
1615     {
1616       mq->specific_address = find_ready_address(neighbour);
1617       GNUNET_STATISTICS_update (stats,
1618                                 gettext_noop ("# transport selected peer address freely"),
1619                                 1,
1620                                 GNUNET_NO);
1621       force_address = GNUNET_NO;
1622     }
1623   if (mq->specific_address == NULL)
1624     {
1625       GNUNET_STATISTICS_update (stats,
1626                                 gettext_noop ("# transport failed to selected peer address"),
1627                                 1,
1628                                 GNUNET_NO);
1629       timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
1630       if (timeout.rel_value == 0)
1631         {
1632 #if DEBUG_TRANSPORT
1633           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1634                       "No destination address available to transmit message of size %u to peer `%4s'\n",
1635                       mq->message_buf_size,
1636                       GNUNET_i2s (&mq->neighbour_id));
1637 #endif
1638           GNUNET_STATISTICS_update (stats,
1639                                     gettext_noop ("# bytes in message queue for other peers"),
1640                                     - (int64_t) mq->message_buf_size,
1641                                     GNUNET_NO);
1642           GNUNET_STATISTICS_update (stats,
1643                                     gettext_noop ("# bytes discarded (no destination address available)"),
1644                                     mq->message_buf_size,
1645                                     GNUNET_NO);
1646           if (mq->client != NULL)
1647             transmit_send_ok (mq->client, neighbour, GNUNET_NO);
1648           GNUNET_CONTAINER_DLL_remove (neighbour->messages_head,
1649                                        neighbour->messages_tail,
1650                                        mq);
1651           GNUNET_free (mq);
1652           return;               /* nobody ready */
1653         }
1654       GNUNET_STATISTICS_update (stats,
1655                                 gettext_noop ("# message delivery deferred (no address)"),
1656                                 1,
1657                                 GNUNET_NO);
1658       if (neighbour->retry_task != GNUNET_SCHEDULER_NO_TASK)
1659         GNUNET_SCHEDULER_cancel (sched,
1660                                  neighbour->retry_task);
1661       neighbour->retry_task = GNUNET_SCHEDULER_add_delayed (sched,
1662                                                             timeout,
1663                                                             &retry_transmission_task,
1664                                                             neighbour);
1665 #if DEBUG_TRANSPORT
1666       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1667                   "No validated destination address available to transmit message of size %u to peer `%4s', will wait %llums to find an address.\n",
1668                   mq->message_buf_size,
1669                   GNUNET_i2s (&mq->neighbour_id),
1670                   timeout.rel_value);
1671 #endif
1672       /* FIXME: might want to trigger peerinfo lookup here
1673          (unless that's already pending...) */
1674       return;
1675     }
1676   GNUNET_CONTAINER_DLL_remove (neighbour->messages_head,
1677                                neighbour->messages_tail,
1678                                mq);
1679   if (mq->specific_address->connected == GNUNET_NO)
1680     mq->specific_address->connect_attempts++;
1681   rl = mq->specific_address->ready_list;
1682   mq->plugin = rl->plugin;
1683   if (!mq->internal_msg)
1684     mq->specific_address->in_transmit = GNUNET_YES;
1685 #if DEBUG_TRANSPORT
1686   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1687               "Sending message of size %u for `%4s' to `%s' via plugin `%s'\n",
1688               mq->message_buf_size,
1689               GNUNET_i2s (&neighbour->id),
1690               (mq->specific_address->addr != NULL)
1691               ? a2s (mq->plugin->short_name,
1692                      mq->specific_address->addr,
1693                      mq->specific_address->addrlen)
1694               : "<inbound>",
1695               rl->plugin->short_name);
1696 #endif
1697   GNUNET_STATISTICS_update (stats,
1698                             gettext_noop ("# bytes in message queue for other peers"),
1699                             - (int64_t) mq->message_buf_size,
1700                             GNUNET_NO);
1701   GNUNET_STATISTICS_update (stats,
1702                             gettext_noop ("# bytes pending with plugins"),
1703                             mq->message_buf_size,
1704                             GNUNET_NO);
1705   ret = rl->plugin->api->send (rl->plugin->api->cls,
1706                                &mq->neighbour_id,
1707                                mq->message_buf,
1708                                mq->message_buf_size,
1709                                mq->priority,
1710                                GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
1711                                mq->specific_address->session,
1712                                mq->specific_address->addr,
1713                                mq->specific_address->addrlen,
1714                                force_address,
1715                                &transmit_send_continuation, mq);
1716   if (ret == -1)
1717     {
1718       /* failure, but 'send' would not call continuation in this case,
1719          so we need to do it here! */
1720       transmit_send_continuation (mq,
1721                                   &mq->neighbour_id,
1722                                   GNUNET_SYSERR);
1723     }
1724 }
1725
1726
1727 /**
1728  * Send the specified message to the specified peer.
1729  *
1730  * @param client source of the transmission request (can be NULL)
1731  * @param peer_address ForeignAddressList where we should send this message
1732  * @param priority how important is the message
1733  * @param timeout how long do we have to transmit?
1734  * @param message_buf message(s) to send GNUNET_MessageHeader(s)
1735  * @param message_buf_size total size of all messages in message_buf
1736  * @param is_internal is this an internal message; these are pre-pended and
1737  *                    also do not count for plugins being "ready" to transmit
1738  * @param neighbour handle to the neighbour for transmission
1739  */
1740 static void
1741 transmit_to_peer (struct TransportClient *client,
1742                   struct ForeignAddressList *peer_address,
1743                   unsigned int priority,
1744                   struct GNUNET_TIME_Relative timeout,
1745                   const char *message_buf,
1746                   size_t message_buf_size,
1747                   int is_internal, struct NeighbourList *neighbour)
1748 {
1749   struct MessageQueue *mq;
1750
1751 #if EXTRA_CHECKS
1752   if (client != NULL)
1753     {
1754       /* check for duplicate submission */
1755       mq = neighbour->messages_head;
1756       while (NULL != mq)
1757         {
1758           if (mq->client == client)
1759             {
1760               /* client transmitted to same peer twice
1761                  before getting SEND_OK! */
1762               GNUNET_break (0);
1763               return;
1764             }
1765           mq = mq->next;
1766         }
1767     }
1768 #endif
1769   GNUNET_STATISTICS_update (stats,
1770                             gettext_noop ("# bytes in message queue for other peers"),
1771                             message_buf_size,
1772                             GNUNET_NO);
1773   mq = GNUNET_malloc (sizeof (struct MessageQueue) + message_buf_size);
1774   mq->specific_address = peer_address;
1775   mq->client = client;
1776   /* FIXME: this memcpy can be up to 7% of our total runtime! */
1777   memcpy (&mq[1], message_buf, message_buf_size);
1778   mq->message_buf = (const char*) &mq[1];
1779   mq->message_buf_size = message_buf_size;
1780   memcpy(&mq->neighbour_id, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
1781   mq->internal_msg = is_internal;
1782   mq->priority = priority;
1783   mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1784   if (is_internal)
1785     GNUNET_CONTAINER_DLL_insert (neighbour->messages_head,
1786                                  neighbour->messages_tail,
1787                                  mq);
1788   else
1789     GNUNET_CONTAINER_DLL_insert_after (neighbour->messages_head,
1790                                        neighbour->messages_tail,
1791                                        neighbour->messages_tail,
1792                                        mq);
1793   try_transmission_to_peer (neighbour);
1794 }
1795
1796
1797 /**
1798  * FIXME: document.
1799  */
1800 struct GeneratorContext
1801 {
1802   struct TransportPlugin *plug_pos;
1803   struct OwnAddressList *addr_pos;
1804   struct GNUNET_TIME_Absolute expiration;
1805 };
1806
1807
1808 /**
1809  * FIXME: document.
1810  */
1811 static size_t
1812 address_generator (void *cls, size_t max, void *buf)
1813 {
1814   struct GeneratorContext *gc = cls;
1815   size_t ret;
1816
1817   while ((gc->addr_pos == NULL) && (gc->plug_pos != NULL))
1818     {
1819       gc->plug_pos = gc->plug_pos->next;
1820       gc->addr_pos = (gc->plug_pos != NULL) ? gc->plug_pos->addresses : NULL;
1821     }
1822   if (NULL == gc->plug_pos)
1823     {
1824
1825       return 0;
1826     }
1827   ret = GNUNET_HELLO_add_address (gc->plug_pos->short_name,
1828                                   gc->expiration,
1829                                   &gc->addr_pos[1],
1830                                   gc->addr_pos->addrlen, buf, max);
1831   gc->addr_pos = gc->addr_pos->next;
1832   return ret;
1833 }
1834
1835
1836 /**
1837  * Construct our HELLO message from all of the addresses of
1838  * all of the transports.
1839  */
1840 static void
1841 refresh_hello ()
1842 {
1843   struct GNUNET_HELLO_Message *hello;
1844   struct TransportClient *cpos;
1845   struct NeighbourList *npos;
1846   struct GeneratorContext gc;
1847
1848   gc.plug_pos = plugins;
1849   gc.addr_pos = plugins != NULL ? plugins->addresses : NULL;
1850   gc.expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
1851   hello = GNUNET_HELLO_create (&my_public_key, &address_generator, &gc);
1852 #if DEBUG_TRANSPORT
1853   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
1854               "Refreshed my `%s', new size is %d\n", "HELLO", GNUNET_HELLO_size(hello));
1855 #endif
1856   GNUNET_STATISTICS_update (stats,
1857                             gettext_noop ("# refreshed my HELLO"),
1858                             1,
1859                             GNUNET_NO);
1860   cpos = clients;
1861   while (cpos != NULL)
1862     {
1863       transmit_to_client (cpos,
1864                           (const struct GNUNET_MessageHeader *) hello,
1865                           GNUNET_NO);
1866       cpos = cpos->next;
1867     }
1868
1869   GNUNET_free_non_null (our_hello);
1870   our_hello = hello;
1871   GNUNET_PEERINFO_add_peer (peerinfo, our_hello);
1872   npos = neighbours;
1873   while (npos != NULL)
1874     {
1875 #if DEBUG_TRANSPORT
1876       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
1877                   "Transmitting updated `%s' to neighbour `%4s'\n",
1878                   "HELLO", GNUNET_i2s (&npos->id));
1879 #endif
1880       GNUNET_STATISTICS_update (stats,
1881                                 gettext_noop ("# transmitted my HELLO to other peers"),
1882                                 1,
1883                                 GNUNET_NO);
1884       transmit_to_peer (NULL, NULL, 0,
1885                         HELLO_ADDRESS_EXPIRATION,
1886                         (const char *) our_hello,
1887                         GNUNET_HELLO_size(our_hello),
1888                         GNUNET_NO, npos);
1889       npos = npos->next;
1890     }
1891 }
1892
1893
1894 /**
1895  * Task used to clean up expired addresses for a plugin.
1896  *
1897  * @param cls closure
1898  * @param tc context
1899  */
1900 static void
1901 expire_address_task (void *cls,
1902                      const struct GNUNET_SCHEDULER_TaskContext *tc);
1903
1904
1905 /**
1906  * Update the list of addresses for this plugin,
1907  * expiring those that are past their expiration date.
1908  *
1909  * @param plugin addresses of which plugin should be recomputed?
1910  * @param fresh set to GNUNET_YES if a new address was added
1911  *        and we need to regenerate the HELLO even if nobody
1912  *        expired
1913  */
1914 static void
1915 update_addresses (struct TransportPlugin *plugin, int fresh)
1916 {
1917   static struct GNUNET_TIME_Absolute last_update;
1918   struct GNUNET_TIME_Relative min_remaining;
1919   struct GNUNET_TIME_Relative remaining;
1920   struct GNUNET_TIME_Absolute now;
1921   struct OwnAddressList *pos;
1922   struct OwnAddressList *prev;
1923   struct OwnAddressList *next;
1924   int expired;
1925
1926   if (plugin->address_update_task != GNUNET_SCHEDULER_NO_TASK)
1927     GNUNET_SCHEDULER_cancel (plugin->env.sched, plugin->address_update_task);
1928   plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
1929   now = GNUNET_TIME_absolute_get ();
1930   min_remaining = GNUNET_TIME_UNIT_FOREVER_REL;
1931   expired = (GNUNET_TIME_absolute_get_duration (last_update).rel_value > (HELLO_ADDRESS_EXPIRATION.rel_value / 4));
1932   prev = NULL;
1933   pos = plugin->addresses;
1934   while (pos != NULL)
1935     {
1936       next = pos->next;
1937       if (pos->expires.abs_value < now.abs_value)
1938         {
1939           expired = GNUNET_YES;
1940           if (prev == NULL)
1941             plugin->addresses = pos->next;
1942           else
1943             prev->next = pos->next;
1944           GNUNET_free (pos);
1945         }
1946       else
1947         {
1948           remaining = GNUNET_TIME_absolute_get_remaining (pos->expires);
1949           if (remaining.rel_value < min_remaining.rel_value)
1950             min_remaining = remaining;
1951           prev = pos;
1952         }
1953       pos = next;
1954     }
1955
1956   if (expired || fresh)
1957     {
1958       last_update = now;
1959       refresh_hello ();
1960     }
1961   min_remaining = GNUNET_TIME_relative_min (min_remaining,
1962                                             GNUNET_TIME_relative_divide (HELLO_ADDRESS_EXPIRATION,
1963                                                                          2));
1964   plugin->address_update_task
1965     = GNUNET_SCHEDULER_add_delayed (plugin->env.sched,
1966                                     min_remaining,
1967                                     &expire_address_task, plugin);
1968 }
1969
1970
1971 /**
1972  * Task used to clean up expired addresses for a plugin.
1973  *
1974  * @param cls closure
1975  * @param tc context
1976  */
1977 static void
1978 expire_address_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1979 {
1980   struct TransportPlugin *plugin = cls;
1981
1982   plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
1983   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1984     update_addresses (plugin, GNUNET_NO);
1985 }
1986
1987
1988 /**
1989  * Iterator over hash map entries that NULLs the session of validation
1990  * entries that match the given session.
1991  *
1992  * @param cls closure (the 'struct Session*' to match against)
1993  * @param key current key code (peer ID, not used)
1994  * @param value value in the hash map ('struct ValidationEntry*')
1995  * @return GNUNET_YES (we should continue to iterate)
1996  */
1997 static int
1998 remove_session_validations (void *cls,
1999                             const GNUNET_HashCode * key,
2000                             void *value)
2001 {
2002   struct Session *session = cls;
2003   struct ValidationEntry *ve = value;
2004
2005   if (session == ve->session)
2006     ve->session = NULL;
2007   return GNUNET_YES;
2008 }
2009
2010
2011 /**
2012  * We've been disconnected from the other peer (for some
2013  * connection-oriented transport).  Either quickly
2014  * re-establish the connection or signal the disconnect
2015  * to the CORE.
2016  *
2017  * Only signal CORE level disconnect if ALL addresses
2018  * for the peer are exhausted.
2019  *
2020  * @param p overall plugin context
2021  * @param nl neighbour that was disconnected
2022  */
2023 static void
2024 try_fast_reconnect (struct TransportPlugin *p,
2025                     struct NeighbourList *nl)
2026 {
2027   /* FIXME-MW: fast reconnect / transport switching not implemented... */
2028   /* Note: the idea here is to hide problems with transports (or
2029      switching between plugins) from the core to eliminate the need to
2030      re-negotiate session keys and the like; OTOH, we should tell core
2031      quickly (much faster than timeout) `if a connection was lost and
2032      could not be re-established (i.e. other peer went down or is
2033      unable / refuses to communicate);
2034
2035      So we should consider:
2036      1) ideally: our own willingness / need to connect
2037      2) prior failures to connect to this peer (by plugin)
2038      3) ideally: reasons why other peer terminated (as far as knowable)
2039
2040      Most importantly, it must be POSSIBLE for another peer to terminate
2041      a connection for a while (without us instantly re-establishing it).
2042      Similarly, if another peer is gone we should quickly notify CORE.
2043      OTOH, if there was a minor glitch (i.e. crash of gnunet-service-transport
2044      on the other end), we should reconnect in such a way that BOTH CORE
2045      services never even notice.
2046      Furthermore, the same mechanism (or small variation) could be used
2047      to switch to a better-performing plugin (ATS).
2048
2049      Finally, this needs to be tested throughly... */
2050
2051   /*
2052    * GNUNET_NO in the call below makes transport disconnect the peer,
2053    * even if only a single address (out of say, six) went away.  This
2054    * function must be careful to ONLY disconnect if the peer is gone,
2055    * not just a specifi address.
2056    *
2057    * More specifically, half the places it was used had it WRONG.
2058    */
2059
2060   /* No reconnect, signal disconnect instead! */
2061   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2062             "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&nl->id),
2063             "try_fast_reconnect");
2064   disconnect_neighbour (nl, GNUNET_YES);
2065 }
2066
2067
2068 /**
2069  * Function that will be called whenever the plugin internally
2070  * cleans up a session pointer and hence the service needs to
2071  * discard all of those sessions as well.  Plugins that do not
2072  * use sessions can simply omit calling this function and always
2073  * use NULL wherever a session pointer is needed.
2074  *
2075  * @param cls closure
2076  * @param peer which peer was the session for
2077  * @param session which session is being destoyed
2078  */
2079 static void
2080 plugin_env_session_end  (void *cls,
2081                          const struct GNUNET_PeerIdentity *peer,
2082                          struct Session *session)
2083 {
2084   struct TransportPlugin *p = cls;
2085   struct NeighbourList *nl;
2086   struct ReadyList *rl;
2087   struct ForeignAddressList *pos;
2088   struct ForeignAddressList *prev;
2089
2090   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
2091                                          &remove_session_validations,
2092                                          session);
2093   nl = find_neighbour (peer);
2094   if (nl == NULL)
2095     return; /* was never marked as connected */
2096   rl = nl->plugins;
2097   while (rl != NULL)
2098     {
2099       if (rl->plugin == p)
2100         break;
2101       rl = rl->next;
2102     }
2103   if (rl == NULL)
2104     return; /* was never marked as connected */
2105   prev = NULL;
2106   pos = rl->addresses;
2107   while ( (pos != NULL) &&
2108           (pos->session != session) )
2109     {
2110       prev = pos;
2111       pos = pos->next;
2112     }
2113   if (pos == NULL)
2114     return; /* was never marked as connected */
2115   pos->session = NULL;
2116   if (pos->addrlen != 0)
2117     {
2118       if (nl->received_pong != GNUNET_NO)
2119         try_fast_reconnect (p, nl);
2120       return;
2121     }
2122   /* was inbound connection, free 'pos' */
2123   if (prev == NULL)
2124     rl->addresses = pos->next;
2125   else
2126     prev->next = pos->next;
2127   if (GNUNET_SCHEDULER_NO_TASK != pos->revalidate_task)
2128     {
2129       GNUNET_SCHEDULER_cancel (sched,
2130                                pos->revalidate_task);
2131       pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
2132     }
2133   GNUNET_free (pos);
2134   if (nl->received_pong == GNUNET_NO)
2135     return; /* nothing to do, never connected... */
2136   /* check if we have any validated addresses left */
2137   pos = rl->addresses;
2138   while (pos != NULL)
2139     {
2140       if (pos->validated)
2141         {
2142           try_fast_reconnect (p, nl);
2143           return;
2144         }
2145       pos = pos->next;
2146     }
2147   /* no valid addresses left, signal disconnect! */
2148
2149   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2150             "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&nl->id),
2151             "plugin_env_session_end");
2152   /* FIXME: This doesn't mean there are no addresses left for this PEER,
2153    * it means there aren't any left for this PLUGIN/PEER combination! So
2154    * calling disconnect_neighbor here with GNUNET_NO forces disconnect
2155    * when it isn't necessary. Using GNUNET_YES at least checks to see
2156    * if there are any addresses that work first, so as not to overdo it.
2157    * --NE
2158    */
2159   disconnect_neighbour (nl, GNUNET_YES);
2160 }
2161
2162
2163 /**
2164  * Function that must be called by each plugin to notify the
2165  * transport service about the addresses under which the transport
2166  * provided by the plugin can be reached.
2167  *
2168  * @param cls closure
2169  * @param name name of the transport that generated the address
2170  * @param addr one of the addresses of the host, NULL for the last address
2171  *        the specific address format depends on the transport
2172  * @param addrlen length of the address
2173  * @param expires when should this address automatically expire?
2174  */
2175 static void
2176 plugin_env_notify_address (void *cls,
2177                            const char *name,
2178                            const void *addr,
2179                            uint16_t addrlen,
2180                            struct GNUNET_TIME_Relative expires)
2181 {
2182   struct TransportPlugin *p = cls;
2183   struct OwnAddressList *al;
2184   struct GNUNET_TIME_Absolute abex;
2185
2186   GNUNET_assert (addr != NULL);
2187   abex = GNUNET_TIME_relative_to_absolute (expires);
2188   GNUNET_assert (p == find_transport (name));
2189   al = p->addresses;
2190   while (al != NULL)
2191     {
2192       if ((addrlen == al->addrlen) && (0 == memcmp (addr, &al[1], addrlen)))
2193         {
2194           if (al->expires.abs_value < abex.abs_value)
2195             al->expires = abex;
2196           return;
2197         }
2198       al = al->next;
2199     }
2200
2201   al = GNUNET_malloc (sizeof (struct OwnAddressList) + addrlen);
2202   al->next = p->addresses;
2203   p->addresses = al;
2204   al->expires = abex;
2205   al->addrlen = addrlen;
2206   memcpy (&al[1], addr, addrlen);
2207   update_addresses (p, GNUNET_YES);
2208 }
2209
2210
2211 /**
2212  * Notify all of our clients about a peer connecting.
2213  */
2214 static void
2215 notify_clients_connect (const struct GNUNET_PeerIdentity *peer,
2216                         struct GNUNET_TIME_Relative latency,
2217                         uint32_t distance)
2218 {
2219   struct ConnectInfoMessage cim;
2220   struct TransportClient *cpos;
2221
2222 #if DEBUG_TRANSPORT
2223   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2224               "Notifying clients about connection from `%s'\n",
2225               GNUNET_i2s (peer));
2226 #endif
2227   GNUNET_STATISTICS_update (stats,
2228                             gettext_noop ("# peers connected"),
2229                             1,
2230                             GNUNET_NO);
2231   cim.header.size = htons (sizeof (struct ConnectInfoMessage));
2232   cim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
2233   cim.distance = htonl (distance);
2234   cim.latency = GNUNET_TIME_relative_hton (latency);
2235   memcpy (&cim.id, peer, sizeof (struct GNUNET_PeerIdentity));
2236   cpos = clients;
2237   while (cpos != NULL)
2238     {
2239       transmit_to_client (cpos, &cim.header, GNUNET_NO);
2240       cpos = cpos->next;
2241     }
2242 }
2243
2244
2245 /**
2246  * Notify all of our clients about a peer disconnecting.
2247  */
2248 static void
2249 notify_clients_disconnect (const struct GNUNET_PeerIdentity *peer)
2250 {
2251   struct DisconnectInfoMessage dim;
2252   struct TransportClient *cpos;
2253
2254 #if DEBUG_TRANSPORT
2255   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2256               "Notifying clients about lost connection to `%s'\n",
2257               GNUNET_i2s (peer));
2258 #endif
2259   GNUNET_STATISTICS_update (stats,
2260                             gettext_noop ("# peers connected"),
2261                             -1,
2262                             GNUNET_NO);
2263   dim.header.size = htons (sizeof (struct DisconnectInfoMessage));
2264   dim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
2265   dim.reserved = htonl (0);
2266   memcpy (&dim.peer, peer, sizeof (struct GNUNET_PeerIdentity));
2267   cpos = clients;
2268   while (cpos != NULL)
2269     {
2270       transmit_to_client (cpos, &dim.header, GNUNET_NO);
2271       cpos = cpos->next;
2272     }
2273 }
2274
2275
2276 /**
2277  * Find a ForeignAddressList entry for the given neighbour
2278  * that matches the given address and transport.
2279  *
2280  * @param neighbour which peer we care about
2281  * @param tname name of the transport plugin
2282  * @param session session to look for, NULL for 'any'; otherwise
2283  *        can be used for the service to "learn" this session ID
2284  *        if 'addr' matches
2285  * @param addr binary address
2286  * @param addrlen length of addr
2287  * @return NULL if no such entry exists
2288  */
2289 static struct ForeignAddressList *
2290 find_peer_address(struct NeighbourList *neighbour,
2291                   const char *tname,
2292                   struct Session *session,
2293                   const char *addr,
2294                   uint16_t addrlen)
2295 {
2296   struct ReadyList *head;
2297   struct ForeignAddressList *pos;
2298
2299   head = neighbour->plugins;
2300   while (head != NULL)
2301     {
2302       if (0 == strcmp (tname, head->plugin->short_name))
2303         break;
2304       head = head->next;
2305     }
2306   if (head == NULL)
2307     return NULL;
2308   pos = head->addresses;
2309   while ( (pos != NULL) &&
2310           ( (pos->addrlen != addrlen) ||
2311             (memcmp(pos->addr, addr, addrlen) != 0) ) )
2312     {
2313       if ( (session != NULL) &&
2314            (pos->session == session) )
2315         return pos;
2316       pos = pos->next;
2317     }
2318   if ( (session != NULL) && (pos != NULL) )
2319     pos->session = session; /* learn it! */
2320   return pos;
2321 }
2322
2323
2324 /**
2325  * Get the peer address struct for the given neighbour and
2326  * address.  If it doesn't yet exist, create it.
2327  *
2328  * @param neighbour which peer we care about
2329  * @param tname name of the transport plugin
2330  * @param session session of the plugin, or NULL for none
2331  * @param addr binary address
2332  * @param addrlen length of addr
2333  * @return NULL if we do not have a transport plugin for 'tname'
2334  */
2335 static struct ForeignAddressList *
2336 add_peer_address (struct NeighbourList *neighbour,
2337                   const char *tname,
2338                   struct Session *session,
2339                   const char *addr,
2340                   uint16_t addrlen)
2341 {
2342   struct ReadyList *head;
2343   struct ForeignAddressList *ret;
2344
2345   ret = find_peer_address (neighbour, tname, session, addr, addrlen);
2346   if (ret != NULL)
2347     return ret;
2348   head = neighbour->plugins;
2349
2350   while (head != NULL)
2351     {
2352       if (0 == strcmp (tname, head->plugin->short_name))
2353         break;
2354       head = head->next;
2355     }
2356   if (head == NULL)
2357     return NULL;
2358   ret = GNUNET_malloc(sizeof(struct ForeignAddressList) + addrlen);
2359   ret->session = session;
2360   if (addrlen > 0)
2361     {
2362       ret->addr = (const char*) &ret[1];
2363       memcpy (&ret[1], addr, addrlen);
2364     }
2365   else
2366     {
2367       ret->addr = NULL;
2368     }
2369   ret->addrlen = addrlen;
2370   ret->expires = GNUNET_TIME_relative_to_absolute
2371     (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
2372   ret->latency = GNUNET_TIME_relative_get_forever();
2373   ret->distance = -1;
2374   ret->timeout = GNUNET_TIME_relative_to_absolute
2375     (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
2376   ret->ready_list = head;
2377   ret->next = head->addresses;
2378   head->addresses = ret;
2379   return ret;
2380 }
2381
2382
2383 /**
2384  * Closure for 'add_validated_address'.
2385  */
2386 struct AddValidatedAddressContext
2387 {
2388   /**
2389    * Entry that has been validated.
2390    */
2391   const struct ValidationEntry *ve;
2392
2393   /**
2394    * Flag set after we have added the address so
2395    * that we terminate the iteration next time.
2396    */
2397   int done;
2398 };
2399
2400
2401 /**
2402  * Callback function used to fill a buffer of max bytes with a list of
2403  * addresses in the format used by HELLOs.  Should use
2404  * "GNUNET_HELLO_add_address" as a helper function.
2405  *
2406  * @param cls the 'struct AddValidatedAddressContext' with the validated address
2407  * @param max maximum number of bytes that can be written to buf
2408  * @param buf where to write the address information
2409  * @return number of bytes written, 0 to signal the
2410  *         end of the iteration.
2411  */
2412 static size_t
2413 add_validated_address (void *cls,
2414                        size_t max, void *buf)
2415 {
2416   struct AddValidatedAddressContext *avac = cls;
2417   const struct ValidationEntry *ve = avac->ve;
2418
2419   if (GNUNET_YES == avac->done)
2420     return 0;
2421   avac->done = GNUNET_YES;
2422   return GNUNET_HELLO_add_address (ve->transport_name,
2423                                    GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION),
2424                                    ve->addr,
2425                                    ve->addrlen,
2426                                    buf,
2427                                    max);
2428 }
2429
2430
2431
2432 /**
2433  * Closure for 'check_address_exists'.
2434  */
2435 struct CheckAddressExistsClosure
2436 {
2437   /**
2438    * Address to check for.
2439    */
2440   const void *addr;
2441
2442   /**
2443    * Name of the transport.
2444    */
2445   const char *tname;
2446
2447   /**
2448    * Session, or NULL.
2449    */
2450   struct Session *session;
2451
2452   /**
2453    * Set to GNUNET_YES if the address exists.
2454    */
2455   int exists;
2456
2457   /**
2458    * Length of addr.
2459    */
2460   uint16_t addrlen;
2461
2462 };
2463
2464
2465 /**
2466  * Iterator over hash map entries.  Checks if the given
2467  * validation entry is for the same address as what is given
2468  * in the closure.
2469  *
2470  * @param cls the 'struct CheckAddressExistsClosure*'
2471  * @param key current key code (ignored)
2472  * @param value value in the hash map ('struct ValidationEntry')
2473  * @return GNUNET_YES if we should continue to
2474  *         iterate (mismatch), GNUNET_NO if not (entry matched)
2475  */
2476 static int
2477 check_address_exists (void *cls,
2478                       const GNUNET_HashCode * key,
2479                       void *value)
2480 {
2481   struct CheckAddressExistsClosure *caec = cls;
2482   struct ValidationEntry *ve = value;
2483
2484   if ( (0 == strcmp (caec->tname,
2485                      ve->transport_name)) &&
2486        (caec->addrlen == ve->addrlen) &&
2487        (0 == memcmp (caec->addr,
2488                      ve->addr,
2489                      caec->addrlen)) )
2490     {
2491       caec->exists = GNUNET_YES;
2492       return GNUNET_NO;
2493     }
2494   if ( (ve->session != NULL) &&
2495        (caec->session == ve->session) )
2496     {
2497       caec->exists = GNUNET_YES;
2498       return GNUNET_NO;
2499     }
2500   return GNUNET_YES;
2501 }
2502
2503
2504
2505 /**
2506  * Iterator to free entries in the validation_map.
2507  *
2508  * @param cls closure (unused)
2509  * @param key current key code
2510  * @param value value in the hash map (validation to abort)
2511  * @return GNUNET_YES (always)
2512  */
2513 static int
2514 abort_validation (void *cls,
2515                   const GNUNET_HashCode * key,
2516                   void *value)
2517 {
2518   struct ValidationEntry *va = value;
2519
2520   if (GNUNET_SCHEDULER_NO_TASK != va->timeout_task)
2521     GNUNET_SCHEDULER_cancel (sched, va->timeout_task);
2522   GNUNET_free (va->transport_name);
2523   if (va->chvc != NULL)
2524     {
2525       va->chvc->ve_count--;
2526       if (va->chvc->ve_count == 0)
2527         {
2528           GNUNET_CONTAINER_DLL_remove (chvc_head,
2529                                        chvc_tail,
2530                                        va->chvc);
2531           GNUNET_free (va->chvc);
2532         }
2533       va->chvc = NULL;
2534     }
2535   GNUNET_free (va);
2536   return GNUNET_YES;
2537 }
2538
2539
2540 /**
2541  * HELLO validation cleanup task (validation failed).
2542  *
2543  * @param cls the 'struct ValidationEntry' that failed
2544  * @param tc scheduler context (unused)
2545  */
2546 static void
2547 timeout_hello_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2548 {
2549   struct ValidationEntry *va = cls;
2550   struct GNUNET_PeerIdentity pid;
2551
2552   va->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2553   GNUNET_STATISTICS_update (stats,
2554                             gettext_noop ("# address validation timeouts"),
2555                             1,
2556                             GNUNET_NO);
2557   GNUNET_CRYPTO_hash (&va->publicKey,
2558                       sizeof (struct
2559                               GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
2560                       &pid.hashPubKey);
2561   GNUNET_break (GNUNET_OK ==
2562                 GNUNET_CONTAINER_multihashmap_remove (validation_map,
2563                                                       &pid.hashPubKey,
2564                                                       va));
2565   abort_validation (NULL, NULL, va);
2566 }
2567
2568
2569 static void
2570 neighbour_timeout_task (void *cls,
2571                        const struct GNUNET_SCHEDULER_TaskContext *tc)
2572 {
2573   struct NeighbourList *n = cls;
2574
2575 #if DEBUG_TRANSPORT
2576   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
2577               "Neighbour `%4s' has timed out!\n", GNUNET_i2s (&n->id));
2578 #endif
2579   GNUNET_STATISTICS_update (stats,
2580                             gettext_noop ("# disconnects due to timeout"),
2581                             1,
2582                             GNUNET_NO);
2583   n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2584   disconnect_neighbour (n, GNUNET_NO);
2585 }
2586
2587
2588 /**
2589  * Schedule the job that will cause us to send a PING to the
2590  * foreign address to evaluate its validity and latency.
2591  *
2592  * @param fal address to PING
2593  */
2594 static void
2595 schedule_next_ping (struct ForeignAddressList *fal);
2596
2597
2598 /**
2599  * Add the given address to the list of foreign addresses
2600  * available for the given peer (check for duplicates).
2601  *
2602  * @param cls the respective 'struct NeighbourList' to update
2603  * @param tname name of the transport
2604  * @param expiration expiration time
2605  * @param addr the address
2606  * @param addrlen length of the address
2607  * @return GNUNET_OK (always)
2608  */
2609 static int
2610 add_to_foreign_address_list (void *cls,
2611                              const char *tname,
2612                              struct GNUNET_TIME_Absolute expiration,
2613                              const void *addr,
2614                              uint16_t addrlen)
2615 {
2616   struct NeighbourList *n = cls;
2617   struct ForeignAddressList *fal;
2618   int try;
2619
2620   GNUNET_STATISTICS_update (stats,
2621                             gettext_noop ("# valid peer addresses returned by PEERINFO"),
2622                             1,
2623                             GNUNET_NO);
2624   try = GNUNET_NO;
2625   fal = find_peer_address (n, tname, NULL, addr, addrlen);
2626   if (fal == NULL)
2627     {
2628 #if DEBUG_TRANSPORT_HELLO
2629       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2630                   "Adding address `%s' (%s) for peer `%4s' due to PEERINFO data for %llums.\n",
2631                   a2s (tname, addr, addrlen),
2632                   tname,
2633                   GNUNET_i2s (&n->id),
2634                   expiration.abs_value);
2635 #endif
2636       fal = add_peer_address (n, tname, NULL, addr, addrlen);
2637       if (fal == NULL)
2638         {
2639           GNUNET_STATISTICS_update (stats,
2640                                     gettext_noop ("# previously validated addresses lacking transport"),
2641                                     1,
2642                                     GNUNET_NO);
2643         }
2644       else
2645         {
2646           fal->expires = GNUNET_TIME_absolute_max (expiration,
2647                                                    fal->expires);
2648           schedule_next_ping (fal);
2649         }
2650       try = GNUNET_YES;
2651     }
2652   else
2653     {
2654       fal->expires = GNUNET_TIME_absolute_max (expiration,
2655                                                fal->expires);
2656     }
2657   if (fal == NULL)
2658     {
2659       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2660                   "Failed to add new address for `%4s'\n",
2661                   GNUNET_i2s (&n->id));
2662       return GNUNET_OK;
2663     }
2664   if (fal->validated == GNUNET_NO)
2665     {
2666       fal->validated = GNUNET_YES;
2667       GNUNET_STATISTICS_update (stats,
2668                                 gettext_noop ("# peer addresses considered valid"),
2669                                 1,
2670                                 GNUNET_NO);
2671     }
2672   if (try == GNUNET_YES)
2673     {
2674       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2675                   "Have new addresses, will try to trigger transmissions.\n");
2676       try_transmission_to_peer (n);
2677     }
2678   return GNUNET_OK;
2679 }
2680
2681
2682 /**
2683  * Add addresses in validated HELLO "h" to the set of addresses
2684  * we have for this peer.
2685  *
2686  * @param cls closure ('struct NeighbourList*')
2687  * @param peer id of the peer, NULL for last call
2688  * @param h hello message for the peer (can be NULL)
2689  */
2690 static void
2691 add_hello_for_peer (void *cls,
2692                     const struct GNUNET_PeerIdentity *peer,
2693                     const struct GNUNET_HELLO_Message *h)
2694 {
2695   struct NeighbourList *n = cls;
2696
2697   if (peer == NULL)
2698     {
2699       GNUNET_STATISTICS_update (stats,
2700                                 gettext_noop ("# outstanding peerinfo iterate requests"),
2701                                 -1,
2702                                 GNUNET_NO);
2703       n->piter = NULL;
2704       return;
2705     }
2706   if (h == NULL)
2707     return; /* no HELLO available */
2708 #if DEBUG_TRANSPORT
2709   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2710               "Peerinfo had `%s' message for peer `%4s', adding existing addresses.\n",
2711               "HELLO",
2712               GNUNET_i2s (peer));
2713 #endif
2714   if (GNUNET_YES != n->public_key_valid)
2715     {
2716       GNUNET_HELLO_get_key (h, &n->publicKey);
2717       n->public_key_valid = GNUNET_YES;
2718     }
2719   GNUNET_HELLO_iterate_addresses (h,
2720                                   GNUNET_NO,
2721                                   &add_to_foreign_address_list,
2722                                   n);
2723 }
2724
2725
2726 /**
2727  * Create a fresh entry in our neighbour list for the given peer.
2728  * Will try to transmit our current HELLO to the new neighbour.
2729  * Do not call this function directly, use 'setup_peer_check_blacklist.
2730  *
2731  * @param peer the peer for which we create the entry
2732  * @param do_hello should we schedule transmitting a HELLO
2733  * @return the new neighbour list entry
2734  */
2735 static struct NeighbourList *
2736 setup_new_neighbour (const struct GNUNET_PeerIdentity *peer,
2737                      int do_hello)
2738 {
2739   struct NeighbourList *n;
2740   struct TransportPlugin *tp;
2741   struct ReadyList *rl;
2742
2743 #if DEBUG_TRANSPORT
2744   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2745               "Setting up state for neighbour `%4s'\n",
2746               GNUNET_i2s (peer));
2747 #endif
2748   GNUNET_assert (our_hello != NULL);
2749   GNUNET_STATISTICS_update (stats,
2750                             gettext_noop ("# active neighbours"),
2751                             1,
2752                             GNUNET_NO);
2753   n = GNUNET_malloc (sizeof (struct NeighbourList));
2754   n->next = neighbours;
2755   neighbours = n;
2756   n->id = *peer;
2757   n->peer_timeout =
2758     GNUNET_TIME_relative_to_absolute
2759     (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
2760   GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
2761                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
2762                                  MAX_BANDWIDTH_CARRY_S);
2763   tp = plugins;
2764   while (tp != NULL)
2765     {
2766       if ((tp->api->send != NULL) && (!is_blacklisted(peer, tp)))
2767         {
2768           rl = GNUNET_malloc (sizeof (struct ReadyList));
2769           rl->neighbour = n;
2770           rl->next = n->plugins;
2771           n->plugins = rl;
2772           rl->plugin = tp;
2773           rl->addresses = NULL;
2774         }
2775       tp = tp->next;
2776     }
2777   n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
2778   n->distance = -1;
2779   n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
2780                                                   GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2781                                                   &neighbour_timeout_task, n);
2782   if (do_hello)
2783     {
2784       GNUNET_STATISTICS_update (stats,
2785                                 gettext_noop ("# peerinfo new neighbor iterate requests"),
2786                                 1,
2787                                 GNUNET_NO);
2788       GNUNET_STATISTICS_update (stats,
2789                                 gettext_noop ("# outstanding peerinfo iterate requests"),
2790                                 1,
2791                                 GNUNET_NO);
2792       n->piter = GNUNET_PEERINFO_iterate (peerinfo, peer,
2793                                           GNUNET_TIME_UNIT_FOREVER_REL,
2794                                           &add_hello_for_peer, n);
2795
2796       GNUNET_STATISTICS_update (stats,
2797                                 gettext_noop ("# HELLO's sent to new neighbors"),
2798                                 1,
2799                                 GNUNET_NO);
2800       transmit_to_peer (NULL, NULL, 0,
2801                         HELLO_ADDRESS_EXPIRATION,
2802                         (const char *) our_hello, GNUNET_HELLO_size(our_hello),
2803                         GNUNET_NO, n);
2804     }
2805   return n;
2806 }
2807
2808
2809 /**
2810  * Function called after we have checked if communicating
2811  * with a given peer is acceptable.
2812  *
2813  * @param cls closure
2814  * @param n NULL if communication is not acceptable
2815  */
2816 typedef void (*SetupContinuation)(void *cls,
2817                                   struct NeighbourList *n);
2818
2819
2820 /**
2821  * Information kept for each client registered to perform
2822  * blacklisting.
2823  */
2824 struct Blacklisters
2825 {
2826   /**
2827    * This is a linked list.
2828    */
2829   struct Blacklisters *next;
2830
2831   /**
2832    * This is a linked list.
2833    */
2834   struct Blacklisters *prev;
2835
2836   /**
2837    * Client responsible for this entry.
2838    */
2839   struct GNUNET_SERVER_Client *client;
2840
2841   /**
2842    * Blacklist check that we're currently performing.
2843    */
2844   struct BlacklistCheck *bc;
2845
2846 };
2847
2848
2849 /**
2850  * Head of DLL of blacklisting clients.
2851  */
2852 static struct Blacklisters *bl_head;
2853
2854 /**
2855  * Tail of DLL of blacklisting clients.
2856  */
2857 static struct Blacklisters *bl_tail;
2858
2859
2860 /**
2861  * Context we use when performing a blacklist check.
2862  */
2863 struct BlacklistCheck
2864 {
2865
2866   /**
2867    * This is a linked list.
2868    */
2869   struct BlacklistCheck *next;
2870
2871   /**
2872    * This is a linked list.
2873    */
2874   struct BlacklistCheck *prev;
2875
2876   /**
2877    * Peer being checked.
2878    */
2879   struct GNUNET_PeerIdentity peer;
2880
2881   /**
2882    * Option for setup neighbour afterwards.
2883    */
2884   int do_hello;
2885
2886   /**
2887    * Continuation to call with the result.
2888    */
2889   SetupContinuation cont;
2890
2891   /**
2892    * Closure for cont.
2893    */
2894   void *cont_cls;
2895
2896   /**
2897    * Current transmission request handle for this client, or NULL if no
2898    * request is pending.
2899    */
2900   struct GNUNET_CONNECTION_TransmitHandle *th;
2901
2902   /**
2903    * Our current position in the blacklisters list.
2904    */
2905   struct Blacklisters *bl_pos;
2906
2907   /**
2908    * Current task performing the check.
2909    */
2910   GNUNET_SCHEDULER_TaskIdentifier task;
2911
2912 };
2913
2914 /**
2915  * Head of DLL of active blacklisting queries.
2916  */
2917 static struct BlacklistCheck *bc_head;
2918
2919 /**
2920  * Tail of DLL of active blacklisting queries.
2921  */
2922 static struct BlacklistCheck *bc_tail;
2923
2924
2925 /**
2926  * Perform next action in the blacklist check.
2927  *
2928  * @param cls the 'struct BlacklistCheck*'
2929  * @param tc unused
2930  */
2931 static void
2932 do_blacklist_check (void *cls,
2933                     const struct GNUNET_SCHEDULER_TaskContext *tc);
2934
2935
2936 /**
2937  * Transmit blacklist query to the client.
2938  *
2939  * @param cls the 'struct BlacklistCheck'
2940  * @param size number of bytes allowed
2941  * @param buf where to copy the message
2942  * @return number of bytes copied to buf
2943  */
2944 static size_t
2945 transmit_blacklist_message (void *cls,
2946                             size_t size,
2947                             void *buf)
2948 {
2949   struct BlacklistCheck *bc = cls;
2950   struct Blacklisters *bl;
2951   struct BlacklistMessage bm;
2952
2953   bc->th = NULL;
2954   if (size == 0)
2955     {
2956       GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
2957       bc->task = GNUNET_SCHEDULER_add_now (sched,
2958                                            &do_blacklist_check,
2959                                            bc);
2960       return 0;
2961     }
2962   bl = bc->bl_pos;
2963   bm.header.size = htons (sizeof (struct BlacklistMessage));
2964   bm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY);
2965   bm.is_allowed = htonl (0);
2966   bm.peer = bc->peer;
2967   memcpy (buf, &bm, sizeof (bm));
2968   GNUNET_SERVER_receive_done (bl->client, GNUNET_OK);
2969   return sizeof (bm);
2970 }
2971
2972
2973 /**
2974  * Perform next action in the blacklist check.
2975  *
2976  * @param cls the 'struct BlacklistCheck*'
2977  * @param tc unused
2978  */
2979 static void
2980 do_blacklist_check (void *cls,
2981                     const struct GNUNET_SCHEDULER_TaskContext *tc)
2982 {
2983   struct BlacklistCheck *bc = cls;
2984   struct Blacklisters *bl;
2985
2986   bc->task = GNUNET_SCHEDULER_NO_TASK;
2987   bl = bc->bl_pos;
2988   if (bl == NULL)
2989     {
2990       bc->cont (bc->cont_cls,
2991                 setup_new_neighbour (&bc->peer, bc->do_hello));
2992       GNUNET_free (bc);
2993       return;
2994     }
2995   if (bl->bc == NULL)
2996     {
2997       bl->bc = bc;
2998       bc->th = GNUNET_SERVER_notify_transmit_ready (bl->client,
2999                                                     sizeof (struct BlacklistMessage),
3000                                                     GNUNET_TIME_UNIT_FOREVER_REL,
3001                                                     &transmit_blacklist_message,
3002                                                     bc);
3003     }
3004 }
3005
3006
3007 /**
3008  * Obtain a 'struct NeighbourList' for the given peer.  If such an entry
3009  * does not yet exist, check the blacklist.  If the blacklist says creating
3010  * one is acceptable, create one and call the continuation; otherwise
3011  * call the continuation with NULL.
3012  *
3013  * @param peer peer to setup or look up a struct NeighbourList for
3014  * @param do_hello should we also schedule sending our HELLO to the peer
3015  *        if this is a new record
3016  * @param cont function to call with the 'struct NeigbhbourList*'
3017  * @param cont_cls closure for cont
3018  */
3019 static void
3020 setup_peer_check_blacklist (const struct GNUNET_PeerIdentity *peer,
3021                             int do_hello,
3022                             SetupContinuation cont,
3023                             void *cont_cls)
3024 {
3025   struct NeighbourList *n;
3026   struct BlacklistCheck *bc;
3027
3028   n = find_neighbour(peer);
3029   if (n != NULL)
3030     {
3031       if (cont != NULL)
3032         cont (cont_cls, n);
3033       return;
3034     }
3035   if (bl_head == NULL)
3036     {
3037       if (cont != NULL)
3038         cont (cont_cls, setup_new_neighbour (peer, do_hello));
3039       else
3040         setup_new_neighbour(peer, do_hello);
3041       return;
3042     }
3043   bc = GNUNET_malloc (sizeof (struct BlacklistCheck));
3044   GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
3045   bc->peer = *peer;
3046   bc->do_hello = do_hello;
3047   bc->cont = cont;
3048   bc->cont_cls = cont_cls;
3049   bc->bl_pos = bl_head;
3050   bc->task = GNUNET_SCHEDULER_add_now (sched,
3051                                        &do_blacklist_check,
3052                                        bc);
3053 }
3054
3055
3056 /**
3057  * Function called with the result of querying a new blacklister about
3058  * it being allowed (or not) to continue to talk to an existing neighbour.
3059  *
3060  * @param cls the original 'struct NeighbourList'
3061  * @param n NULL if we need to disconnect
3062  */
3063 static void
3064 confirm_or_drop_neighbour (void *cls,
3065                            struct NeighbourList *n)
3066 {
3067   struct NeighbourList * orig = cls;
3068
3069   if (n == NULL)
3070     {
3071       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3072               "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&orig->id),
3073               "confirm_or_drop_neighboUr");
3074       disconnect_neighbour (orig, GNUNET_NO);
3075     }
3076 }
3077
3078
3079 /**
3080  * Handle a request to start a blacklist.
3081  *
3082  * @param cls closure (always NULL)
3083  * @param client identification of the client
3084  * @param message the actual message
3085  */
3086 static void
3087 handle_blacklist_init (void *cls,
3088                        struct GNUNET_SERVER_Client *client,
3089                        const struct GNUNET_MessageHeader *message)
3090 {
3091   struct Blacklisters *bl;
3092   struct BlacklistCheck *bc;
3093   struct NeighbourList *n;
3094
3095   bl = bl_head;
3096   while (bl != NULL)
3097     {
3098       if (bl->client == client)
3099         {
3100           GNUNET_break (0);
3101           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3102           return;
3103         }
3104       bl = bl->next;
3105     }
3106   bl = GNUNET_malloc (sizeof (struct Blacklisters));
3107   bl->client = client;
3108   GNUNET_SERVER_client_keep (client);
3109   GNUNET_CONTAINER_DLL_insert_after (bl_head, bl_tail, bl_tail, bl);
3110   /* confirm that all existing connections are OK! */
3111   n = neighbours;
3112   while (NULL != n)
3113     {
3114       bc = GNUNET_malloc (sizeof (struct BlacklistCheck));
3115       GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
3116       bc->peer = n->id;
3117       bc->do_hello = GNUNET_NO;
3118       bc->cont = &confirm_or_drop_neighbour;
3119       bc->cont_cls = n;
3120       bc->bl_pos = bl;
3121       if (n == neighbours) /* all would wait for the same client, no need to
3122                               create more than just the first task right now */
3123         bc->task = GNUNET_SCHEDULER_add_now (sched,
3124                                              &do_blacklist_check,
3125                                              bc);
3126       n = n->next;
3127     }
3128 }
3129
3130
3131 /**
3132  * Handle a request to blacklist a peer.
3133  *
3134  * @param cls closure (always NULL)
3135  * @param client identification of the client
3136  * @param message the actual message
3137  */
3138 static void
3139 handle_blacklist_reply (void *cls,
3140                         struct GNUNET_SERVER_Client *client,
3141                         const struct GNUNET_MessageHeader *message)
3142 {
3143   const struct BlacklistMessage *msg = (const struct BlacklistMessage*) message;
3144   struct Blacklisters *bl;
3145   struct BlacklistCheck *bc;
3146
3147   bl = bl_head;
3148   while ( (bl != NULL) &&
3149           (bl->client != client) )
3150     bl = bl->next;
3151   if (bl == NULL)
3152     {
3153       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3154       return;
3155     }
3156   bc = bl->bc;
3157   bl->bc = NULL;
3158   if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
3159     {
3160       bc->cont (bc->cont_cls, NULL);
3161       GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
3162       GNUNET_free (bc);
3163     }
3164   else
3165     {
3166       bc->bl_pos = bc->bl_pos->next;
3167       bc->task = GNUNET_SCHEDULER_add_now (sched,
3168                                            &do_blacklist_check,
3169                                            bc);
3170     }
3171   /* check if any other bc's are waiting for this blacklister */
3172   bc = bc_head;
3173   while (bc != NULL)
3174     {
3175       if ( (bc->bl_pos == bl) &&
3176            (GNUNET_SCHEDULER_NO_TASK == bc->task) )
3177         bc->task = GNUNET_SCHEDULER_add_now (sched,
3178                                              &do_blacklist_check,
3179                                              bc);
3180       bc = bc->next;
3181     }
3182 }
3183
3184
3185 /**
3186  * Send periodic PING messages to a given foreign address.
3187  *
3188  * @param cls our 'struct PeriodicValidationContext*'
3189  * @param tc task context
3190  */
3191 static void
3192 send_periodic_ping (void *cls,
3193                     const struct GNUNET_SCHEDULER_TaskContext *tc)
3194 {
3195   struct ForeignAddressList *peer_address = cls;
3196   struct TransportPlugin *tp;
3197   struct ValidationEntry *va;
3198   struct NeighbourList *neighbour;
3199   struct TransportPingMessage ping;
3200   struct CheckAddressExistsClosure caec;
3201   char * message_buf;
3202   uint16_t hello_size;
3203   size_t slen;
3204   size_t tsize;
3205
3206   peer_address->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
3207   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
3208     return;
3209   tp = peer_address->ready_list->plugin;
3210   neighbour = peer_address->ready_list->neighbour;
3211   if (GNUNET_YES != neighbour->public_key_valid)
3212     {
3213       /* no public key yet, try again later */
3214       schedule_next_ping (peer_address);
3215       return;
3216     }
3217   caec.addr = peer_address->addr;
3218   caec.addrlen = peer_address->addrlen;
3219   caec.tname = tp->short_name;
3220   caec.session = peer_address->session;
3221   caec.exists = GNUNET_NO;
3222   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
3223                                          &check_address_exists,
3224                                          &caec);
3225   if (caec.exists == GNUNET_YES)
3226     {
3227       /* During validation attempts we will likely trigger the other
3228          peer trying to validate our address which in turn will cause
3229          it to send us its HELLO, so we expect to hit this case rather
3230          frequently.  Only print something if we are very verbose. */
3231 #if DEBUG_TRANSPORT > 1
3232       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3233                   "Some validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
3234                   (peer_address->addr != NULL)
3235                   ? a2s (tp->short_name,
3236                          peer_address->addr,
3237                          peer_address->addrlen)
3238                   : "<inbound>",
3239                   tp->short_name,
3240                   GNUNET_i2s (&neighbour->id));
3241 #endif
3242       schedule_next_ping (peer_address);
3243       return;
3244     }
3245   va = GNUNET_malloc (sizeof (struct ValidationEntry) + peer_address->addrlen);
3246   va->transport_name = GNUNET_strdup (tp->short_name);
3247   va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
3248                                             UINT_MAX);
3249   va->send_time = GNUNET_TIME_absolute_get();
3250   va->session = peer_address->session;
3251   if (peer_address->addr != NULL)
3252     {
3253       va->addr = (const void*) &va[1];
3254       memcpy (&va[1], peer_address->addr, peer_address->addrlen);
3255       va->addrlen = peer_address->addrlen;
3256     }
3257   memcpy(&va->publicKey,
3258          &neighbour->publicKey,
3259          sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
3260
3261   va->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
3262                                                    HELLO_VERIFICATION_TIMEOUT,
3263                                                    &timeout_hello_validation,
3264                                                    va);
3265   GNUNET_CONTAINER_multihashmap_put (validation_map,
3266                                      &neighbour->id.hashPubKey,
3267                                      va,
3268                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3269
3270   if (peer_address->validated != GNUNET_YES)
3271     hello_size = GNUNET_HELLO_size(our_hello);
3272   else
3273     hello_size = 0;
3274
3275   tsize = sizeof(struct TransportPingMessage) + hello_size;
3276
3277   if (peer_address->addr != NULL)
3278     {
3279       slen = strlen (tp->short_name) + 1;
3280       tsize += slen + peer_address->addrlen;
3281     }
3282   else
3283     {
3284       slen = 0; /* make gcc happy */
3285     }
3286   message_buf = GNUNET_malloc(tsize);
3287   ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
3288   ping.challenge = htonl(va->challenge);
3289   memcpy(&ping.target, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
3290   if (peer_address->validated != GNUNET_YES)
3291     {
3292       memcpy(message_buf, our_hello, hello_size);
3293     }
3294
3295   if (peer_address->addr != NULL)
3296     {
3297       ping.header.size = htons(sizeof(struct TransportPingMessage) +
3298                                peer_address->addrlen +
3299                                slen);
3300       memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage)],
3301              tp->short_name,
3302              slen);
3303       memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage) + slen],
3304              peer_address->addr,
3305              peer_address->addrlen);
3306     }
3307   else
3308     {
3309       ping.header.size = htons(sizeof(struct TransportPingMessage));
3310     }
3311
3312   memcpy(&message_buf[hello_size],
3313          &ping,
3314          sizeof(struct TransportPingMessage));
3315
3316 #if DEBUG_TRANSPORT_REVALIDATION
3317   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3318               "Performing re-validation of address `%s' via `%s' for peer `%4s' sending `%s' (%u bytes) and `%s'\n",
3319               (peer_address->addr != NULL)
3320               ? a2s (peer_address->plugin->short_name,
3321                      peer_address->addr,
3322                      peer_address->addrlen)
3323               : "<inbound>",
3324               tp->short_name,
3325               GNUNET_i2s (&neighbour->id),
3326               "HELLO", hello_size,
3327               "PING");
3328 #endif
3329   if (peer_address->validated != GNUNET_YES)
3330     GNUNET_STATISTICS_update (stats,
3331                               gettext_noop ("# PING with HELLO messages sent"),
3332                               1,
3333                               GNUNET_NO);
3334   else
3335     GNUNET_STATISTICS_update (stats,
3336                               gettext_noop ("# PING without HELLO messages sent"),
3337                               1,
3338                               GNUNET_NO);
3339   GNUNET_STATISTICS_update (stats,
3340                             gettext_noop ("# PING messages sent for re-validation"),
3341                             1,
3342                             GNUNET_NO);
3343   transmit_to_peer (NULL, peer_address,
3344                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
3345                     HELLO_VERIFICATION_TIMEOUT,
3346                     message_buf, tsize,
3347                     GNUNET_YES, neighbour);
3348   GNUNET_free(message_buf);
3349   schedule_next_ping (peer_address);
3350 }
3351
3352
3353 /**
3354  * Schedule the job that will cause us to send a PING to the
3355  * foreign address to evaluate its validity and latency.
3356  *
3357  * @param fal address to PING
3358  */
3359 static void
3360 schedule_next_ping (struct ForeignAddressList *fal)
3361 {
3362   struct GNUNET_TIME_Relative delay;
3363
3364   if (fal->revalidate_task != GNUNET_SCHEDULER_NO_TASK)
3365     return;
3366   delay = GNUNET_TIME_absolute_get_remaining (fal->expires);
3367   delay.rel_value /= 2; /* do before expiration */
3368   delay = GNUNET_TIME_relative_min (delay,
3369                                     LATENCY_EVALUATION_MAX_DELAY);
3370   if (GNUNET_YES != fal->estimated)
3371     {
3372       delay = GNUNET_TIME_UNIT_ZERO;
3373       fal->estimated = GNUNET_YES;
3374     }
3375   if (GNUNET_YES == fal->connected)
3376     {
3377       delay = GNUNET_TIME_relative_min (delay,
3378                                         CONNECTED_LATENCY_EVALUATION_MAX_DELAY);
3379     }
3380   /* FIXME: also adjust delay based on how close the last
3381      observed latency is to the latency of the best alternative */
3382   /* bound how fast we can go */
3383   delay = GNUNET_TIME_relative_max (delay,
3384                                     GNUNET_TIME_UNIT_SECONDS);
3385   /* randomize a bit (to avoid doing all at the same time) */
3386   delay.rel_value += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
3387   fal->revalidate_task = GNUNET_SCHEDULER_add_delayed(sched,
3388                                                       delay,
3389                                                       &send_periodic_ping,
3390                                                       fal);
3391 }
3392
3393
3394
3395
3396 /**
3397  * Function that will be called if we receive some payload
3398  * from another peer.
3399  *
3400  * @param message the payload
3401  * @param n peer who claimed to be the sender
3402  */
3403 static void
3404 handle_payload_message (const struct GNUNET_MessageHeader *message,
3405                         struct NeighbourList *n)
3406 {
3407   struct InboundMessage *im;
3408   struct TransportClient *cpos;
3409   uint16_t msize;
3410
3411   msize = ntohs (message->size);
3412   if (n->received_pong == GNUNET_NO)
3413     {
3414       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3415                   "Received message of type %u and size %u from `%4s', but no pong yet!!\n",
3416                   ntohs (message->type),
3417                   ntohs (message->size),
3418                   GNUNET_i2s (&n->id));
3419       GNUNET_free_non_null (n->pre_connect_message_buffer);
3420       n->pre_connect_message_buffer = GNUNET_malloc (msize);
3421       memcpy (n->pre_connect_message_buffer, message, msize);
3422       return;
3423     }
3424
3425 #if DEBUG_TRANSPORT
3426   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3427               "Received message of type %u and size %u from `%4s', sending to all clients.\n",
3428               ntohs (message->type),
3429               ntohs (message->size),
3430               GNUNET_i2s (&n->id));
3431 #endif
3432   if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
3433                                                       (ssize_t) msize))
3434     {
3435       n->quota_violation_count++;
3436 #if DEBUG_TRANSPORT
3437       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3438                   "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
3439                   n->in_tracker.available_bytes_per_s__,
3440                   n->quota_violation_count);
3441 #endif
3442       /* Discount 32k per violation */
3443       GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
3444                                         - 32 * 1024);
3445     }
3446   else
3447     {
3448       if (n->quota_violation_count > 0)
3449         {
3450           /* try to add 32k back */
3451           GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
3452                                             32 * 1024);
3453           n->quota_violation_count--;
3454         }
3455     }
3456   GNUNET_STATISTICS_update (stats,
3457                             gettext_noop ("# payload received from other peers"),
3458                             msize,
3459                             GNUNET_NO);
3460   /* transmit message to all clients */
3461   im = GNUNET_malloc (sizeof (struct InboundMessage) + msize);
3462   im->header.size = htons (sizeof (struct InboundMessage) + msize);
3463   im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
3464   im->latency = GNUNET_TIME_relative_hton (n->latency);
3465   im->peer = n->id;
3466   im->distance = ntohl(n->distance);
3467   memcpy (&im[1], message, msize);
3468   cpos = clients;
3469   while (cpos != NULL)
3470     {
3471       transmit_to_client (cpos, &im->header, GNUNET_YES);
3472       cpos = cpos->next;
3473     }
3474   GNUNET_free (im);
3475 }
3476
3477
3478 /**
3479  * Iterator over hash map entries.  Checks if the given validation
3480  * entry is for the same challenge as what is given in the PONG.
3481  *
3482  * @param cls the 'struct TransportPongMessage*'
3483  * @param key peer identity
3484  * @param value value in the hash map ('struct ValidationEntry')
3485  * @return GNUNET_YES if we should continue to
3486  *         iterate (mismatch), GNUNET_NO if not (entry matched)
3487  */
3488 static int
3489 check_pending_validation (void *cls,
3490                           const GNUNET_HashCode * key,
3491                           void *value)
3492 {
3493   const struct TransportPongMessage *pong = cls;
3494   struct ValidationEntry *ve = value;
3495   struct AddValidatedAddressContext avac;
3496   unsigned int challenge = ntohl(pong->challenge);
3497   struct GNUNET_HELLO_Message *hello;
3498   struct GNUNET_PeerIdentity target;
3499   struct NeighbourList *n;
3500   struct ForeignAddressList *fal;
3501   struct OwnAddressList *oal;
3502   struct TransportPlugin *tp;
3503   struct GNUNET_MessageHeader *prem;
3504   uint16_t ps;
3505   const char *addr;
3506   size_t slen;
3507   size_t alen;
3508
3509   ps = ntohs (pong->header.size);
3510   if (ps < sizeof (struct TransportPongMessage))
3511     {
3512       GNUNET_break_op (0);
3513       return GNUNET_NO;
3514     }
3515   addr = (const char*) &pong[1];
3516   slen = strlen (ve->transport_name) + 1;
3517   if ( (ps - sizeof (struct TransportPongMessage) < slen) ||
3518        (ve->challenge != challenge) ||
3519        (addr[slen-1] != '\0') ||
3520        (0 != strcmp (addr, ve->transport_name)) ||
3521        (ntohl (pong->purpose.size)
3522         != sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
3523         sizeof (uint32_t) +
3524         sizeof (struct GNUNET_TIME_AbsoluteNBO) +
3525         sizeof (struct GNUNET_PeerIdentity) + ps - sizeof (struct TransportPongMessage)) )
3526     {
3527       return GNUNET_YES;
3528     }
3529
3530   alen = ps - sizeof (struct TransportPongMessage) - slen;
3531   switch (ntohl (pong->purpose.purpose))
3532     {
3533     case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN:
3534       if ( (ve->addrlen + slen != ntohl (pong->addrlen)) ||
3535            (0 != memcmp (&addr[slen],
3536                          ve->addr,
3537                          ve->addrlen)) )
3538         {
3539           return GNUNET_YES; /* different entry, keep trying! */
3540         }
3541       if (0 != memcmp (&pong->pid,
3542                        key,
3543                        sizeof (struct GNUNET_PeerIdentity)))
3544         {
3545           GNUNET_break_op (0);
3546           return GNUNET_NO;
3547         }
3548       if (GNUNET_OK !=
3549           GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
3550                                     &pong->purpose,
3551                                     &pong->signature,
3552                                     &ve->publicKey))
3553         {
3554           GNUNET_break_op (0);
3555           return GNUNET_NO;
3556         }
3557
3558 #if DEBUG_TRANSPORT
3559       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3560                   "Confirmed validity of address, peer `%4s' has address `%s' (%s).\n",
3561                   GNUNET_h2s (key),
3562                   a2s (ve->transport_name,
3563                        (const struct sockaddr *) ve->addr,
3564                        ve->addrlen),
3565                   ve->transport_name);
3566 #endif
3567       break;
3568     case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING:
3569       if (0 != memcmp (&pong->pid,
3570                          &my_identity,
3571                          sizeof (struct GNUNET_PeerIdentity)))
3572         {
3573           GNUNET_break_op (0);
3574           return GNUNET_NO;
3575         }
3576       if (ve->addrlen != 0)
3577         {
3578           /* must have been for a different validation entry */
3579           return GNUNET_YES;
3580         }
3581       tp = find_transport (ve->transport_name);
3582       if (tp == NULL)
3583         {
3584           GNUNET_break (0);
3585           return GNUNET_YES;
3586         }
3587       oal = tp->addresses;
3588       while (NULL != oal)
3589         {
3590           if ( (oal->addrlen == alen) &&
3591                (0 == memcmp (&oal[1],
3592                              &addr[slen],
3593                              alen)) )
3594             break;
3595           oal = oal->next;
3596         }
3597       if (oal == NULL)
3598         {
3599           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3600                       _("Not accepting PONG with address `%s' since I cannot confirm having this address.\n"),
3601                       a2s (ve->transport_name,
3602                            &addr[slen],
3603                            alen));
3604           return GNUNET_NO;
3605         }
3606       if (GNUNET_OK !=
3607           GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING,
3608                                     &pong->purpose,
3609                                     &pong->signature,
3610                                     &ve->publicKey))
3611         {
3612           GNUNET_break_op (0);
3613           return GNUNET_NO;
3614         }
3615
3616 #if DEBUG_TRANSPORT
3617       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3618                   "Confirmed that peer `%4s' is talking to us using address `%s' (%s) for us.\n",
3619                   GNUNET_h2s (key),
3620                   a2s (ve->transport_name,
3621                        &addr[slen],
3622                        alen),
3623                   ve->transport_name);
3624 #endif
3625       break;
3626     default:
3627       GNUNET_break_op (0);
3628       return GNUNET_NO;
3629     }
3630   if (GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (pong->expiration)).rel_value == 0)
3631     {
3632       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3633                   _("Received expired signature.  Check system time.\n"));
3634       return GNUNET_NO;
3635     }
3636   GNUNET_STATISTICS_update (stats,
3637                             gettext_noop ("# address validation successes"),
3638                             1,
3639                             GNUNET_NO);
3640   /* create the updated HELLO */
3641   GNUNET_CRYPTO_hash (&ve->publicKey,
3642                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
3643                       &target.hashPubKey);
3644   if (ve->addr != NULL)
3645     {
3646       avac.done = GNUNET_NO;
3647       avac.ve = ve;
3648       hello = GNUNET_HELLO_create (&ve->publicKey,
3649                                    &add_validated_address,
3650                                    &avac);
3651       GNUNET_PEERINFO_add_peer (peerinfo,
3652                                 hello);
3653       GNUNET_free (hello);
3654     }
3655   n = find_neighbour (&target);
3656   if (n != NULL)
3657     {
3658       n->publicKey = ve->publicKey;
3659       n->public_key_valid = GNUNET_YES;
3660       fal = add_peer_address (n,
3661                               ve->transport_name,
3662                               ve->session,
3663                               ve->addr,
3664                               ve->addrlen);
3665       GNUNET_assert (fal != NULL);
3666       fal->expires = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
3667       fal->validated = GNUNET_YES;
3668       mark_address_connected (fal);
3669       GNUNET_STATISTICS_update (stats,
3670                                 gettext_noop ("# peer addresses considered valid"),
3671                                 1,
3672                                 GNUNET_NO);
3673       fal->latency = GNUNET_TIME_absolute_get_duration (ve->send_time);
3674       schedule_next_ping (fal);
3675       if (n->latency.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
3676         n->latency = fal->latency;
3677       else
3678         n->latency.rel_value = (fal->latency.rel_value + n->latency.rel_value) / 2;
3679
3680       n->distance = fal->distance;
3681       if (GNUNET_NO == n->received_pong)
3682         {
3683           n->received_pong = GNUNET_YES;
3684           notify_clients_connect (&target, n->latency, n->distance);
3685           if (NULL != (prem = n->pre_connect_message_buffer))
3686             {
3687               n->pre_connect_message_buffer = NULL;
3688               handle_payload_message (prem, n);
3689               GNUNET_free (prem);
3690             }
3691         }
3692       if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
3693         {
3694           GNUNET_SCHEDULER_cancel (sched,
3695                                    n->retry_task);
3696           n->retry_task = GNUNET_SCHEDULER_NO_TASK;
3697           try_transmission_to_peer (n);
3698         }
3699     }
3700
3701   /* clean up validation entry */
3702   GNUNET_assert (GNUNET_YES ==
3703                  GNUNET_CONTAINER_multihashmap_remove (validation_map,
3704                                                        key,
3705                                                        ve));
3706   abort_validation (NULL, NULL, ve);
3707   return GNUNET_NO;
3708 }
3709
3710
3711 /**
3712  * Function that will be called if we receive a validation
3713  * of an address challenge that we transmitted to another
3714  * peer.  Note that the validation should only be considered
3715  * acceptable if the challenge matches AND if the sender
3716  * address is at least a plausible address for this peer
3717  * (otherwise we may be seeing a MiM attack).
3718  *
3719  * @param cls closure
3720  * @param message the pong message
3721  * @param peer who responded to our challenge
3722  * @param sender_address string describing our sender address (as observed
3723  *         by the other peer in binary format)
3724  * @param sender_address_len number of bytes in 'sender_address'
3725  */
3726 static void
3727 handle_pong (void *cls, const struct GNUNET_MessageHeader *message,
3728              const struct GNUNET_PeerIdentity *peer,
3729              const char *sender_address,
3730              size_t sender_address_len)
3731 {
3732 #if DEBUG_TRANSPORT > 1
3733   /* we get tons of these that just get discarded, only log
3734      if we are quite verbose */
3735   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3736               "Receiving `%s' message from `%4s'.\n", "PONG",
3737               GNUNET_i2s (peer));
3738 #endif
3739   GNUNET_STATISTICS_update (stats,
3740                             gettext_noop ("# PONG messages received"),
3741                             1,
3742                             GNUNET_NO);
3743   if (GNUNET_SYSERR !=
3744       GNUNET_CONTAINER_multihashmap_get_multiple (validation_map,
3745                                                   &peer->hashPubKey,
3746                                                   &check_pending_validation,
3747                                                   (void*) message))
3748     {
3749       /* This is *expected* to happen a lot since we send
3750          PONGs to *all* known addresses of the sender of
3751          the PING, so most likely we get multiple PONGs
3752          per PING, and all but the first PONG will end up
3753          here. So really we should not print anything here
3754          unless we want to be very, very verbose... */
3755 #if DEBUG_TRANSPORT > 2
3756       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3757                   "Received `%s' message from `%4s' but have no record of a matching `%s' message. Ignoring.\n",
3758                   "PONG",
3759                   GNUNET_i2s (peer),
3760                   "PING");
3761 #endif
3762       return;
3763     }
3764
3765 }
3766
3767
3768 /**
3769  * Try to validate a neighbour's address by sending him our HELLO and a PING.
3770  *
3771  * @param cls the 'struct ValidationEntry*'
3772  * @param neighbour neighbour to validate, NULL if validation failed
3773  */
3774 static void
3775 transmit_hello_and_ping (void *cls,
3776                          struct NeighbourList *neighbour)
3777 {
3778   struct ValidationEntry *va = cls;
3779   struct ForeignAddressList *peer_address;
3780   struct TransportPingMessage ping;
3781   uint16_t hello_size;
3782   size_t tsize;
3783   char * message_buf;
3784   struct GNUNET_PeerIdentity id;
3785   size_t slen;
3786
3787   GNUNET_CRYPTO_hash (&va->publicKey,
3788                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
3789                       &id.hashPubKey);
3790   if (neighbour == NULL)
3791     {
3792       /* FIXME: stats... */
3793       GNUNET_break (GNUNET_OK ==
3794                     GNUNET_CONTAINER_multihashmap_remove (validation_map,
3795                                                           &id.hashPubKey,
3796                                                           va));
3797       abort_validation (NULL, NULL, va);
3798       return;
3799     }
3800   neighbour->publicKey = va->publicKey;
3801   neighbour->public_key_valid = GNUNET_YES;
3802   peer_address = add_peer_address (neighbour,
3803                                    va->transport_name, NULL,
3804                                    (const void*) &va[1],
3805                                    va->addrlen);
3806   if (peer_address == NULL)
3807     {
3808       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3809                   "Failed to add peer `%4s' for plugin `%s'\n",
3810                   GNUNET_i2s (&neighbour->id),
3811                   va->transport_name);
3812       GNUNET_break (GNUNET_OK ==
3813                     GNUNET_CONTAINER_multihashmap_remove (validation_map,
3814                                                           &id.hashPubKey,
3815                                                           va));
3816       abort_validation (NULL, NULL, va);
3817       return;
3818     }
3819   hello_size = GNUNET_HELLO_size(our_hello);
3820   slen = strlen(va->transport_name) + 1;
3821   tsize = sizeof(struct TransportPingMessage) + hello_size + va->addrlen + slen;
3822   message_buf = GNUNET_malloc(tsize);
3823   ping.challenge = htonl(va->challenge);
3824   ping.header.size = htons(sizeof(struct TransportPingMessage) + slen + va->addrlen);
3825   ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
3826   memcpy(&ping.target, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
3827   memcpy(message_buf, our_hello, hello_size);
3828   memcpy(&message_buf[hello_size],
3829          &ping,
3830          sizeof(struct TransportPingMessage));
3831   memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage)],
3832          va->transport_name,
3833          slen);
3834   memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage) + slen],
3835          &va[1],
3836          va->addrlen);
3837 #if DEBUG_TRANSPORT
3838   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3839               "Performing validation of address `%s' via `%s' for peer `%4s' sending `%s' (%u bytes) and `%s' (%u bytes)\n",
3840               (va->addrlen == 0)
3841               ? "<inbound>"
3842               : a2s (va->transport_name,
3843                      (const void*) &va[1], va->addrlen),
3844               va->transport_name,
3845               GNUNET_i2s (&neighbour->id),
3846               "HELLO", hello_size,
3847               "PING", sizeof (struct TransportPingMessage) + va->addrlen + slen);
3848 #endif
3849
3850   GNUNET_STATISTICS_update (stats,
3851                             gettext_noop ("# PING messages sent for initial validation"),
3852                             1,
3853                             GNUNET_NO);
3854   transmit_to_peer (NULL, peer_address,
3855                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
3856                     HELLO_VERIFICATION_TIMEOUT,
3857                     message_buf, tsize,
3858                     GNUNET_YES, neighbour);
3859   GNUNET_free(message_buf);
3860 }
3861
3862
3863 /**
3864  * Check if the given address is already being validated; if not,
3865  * append the given address to the list of entries that are being be
3866  * validated and initiate validation.
3867  *
3868  * @param cls closure ('struct CheckHelloValidatedContext *')
3869  * @param tname name of the transport
3870  * @param expiration expiration time
3871  * @param addr the address
3872  * @param addrlen length of the address
3873  * @return GNUNET_OK (always)
3874  */
3875 static int
3876 run_validation (void *cls,
3877                 const char *tname,
3878                 struct GNUNET_TIME_Absolute expiration,
3879                 const void *addr,
3880                 uint16_t addrlen)
3881 {
3882   struct CheckHelloValidatedContext *chvc = cls;
3883   struct GNUNET_PeerIdentity id;
3884   struct TransportPlugin *tp;
3885   struct ValidationEntry *va;
3886   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk;
3887   struct CheckAddressExistsClosure caec;
3888   struct OwnAddressList *oal;
3889
3890   GNUNET_assert (addr != NULL);
3891
3892   GNUNET_STATISTICS_update (stats,
3893                             gettext_noop ("# peer addresses scheduled for validation"),
3894                             1,
3895                             GNUNET_NO);
3896   tp = find_transport (tname);
3897   if (tp == NULL)
3898     {
3899       GNUNET_log (GNUNET_ERROR_TYPE_INFO |
3900                   GNUNET_ERROR_TYPE_BULK,
3901                   _
3902                   ("Transport `%s' not loaded, will not try to validate peer address using this transport.\n"),
3903                   tname);
3904       GNUNET_STATISTICS_update (stats,
3905                                 gettext_noop ("# peer addresses not validated (plugin not available)"),
3906                                 1,
3907                                 GNUNET_NO);
3908       return GNUNET_OK;
3909     }
3910   /* check if this is one of our own addresses */
3911   oal = tp->addresses;
3912   while (NULL != oal)
3913     {
3914       if ( (oal->addrlen == addrlen) &&
3915            (0 == memcmp (&oal[1],
3916                          addr,
3917                          addrlen)) )
3918         {
3919           /* not plausible, this address is equivalent to our own address! */
3920           GNUNET_STATISTICS_update (stats,
3921                                     gettext_noop ("# peer addresses not validated (loopback)"),
3922                                     1,
3923                                     GNUNET_NO);
3924           return GNUNET_OK;
3925         }
3926       oal = oal->next;
3927     }
3928   GNUNET_HELLO_get_key (chvc->hello, &pk);
3929   GNUNET_CRYPTO_hash (&pk,
3930                       sizeof (struct
3931                               GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
3932                       &id.hashPubKey);
3933
3934   if (is_blacklisted(&id, tp))
3935     {
3936 #if DEBUG_TRANSPORT
3937       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3938                   "Attempted to validate blacklisted peer `%s' using `%s'!\n",
3939                   GNUNET_i2s(&id),
3940                   tname);
3941 #endif
3942       return GNUNET_OK;
3943     }
3944
3945   caec.addr = addr;
3946   caec.addrlen = addrlen;
3947   caec.session = NULL;
3948   caec.tname = tname;
3949   caec.exists = GNUNET_NO;
3950   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
3951                                          &check_address_exists,
3952                                          &caec);
3953   if (caec.exists == GNUNET_YES)
3954     {
3955       /* During validation attempts we will likely trigger the other
3956          peer trying to validate our address which in turn will cause
3957          it to send us its HELLO, so we expect to hit this case rather
3958          frequently.  Only print something if we are very verbose. */
3959 #if DEBUG_TRANSPORT > 1
3960       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3961                   "Validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
3962                   a2s (tname, addr, addrlen),
3963                   tname,
3964                   GNUNET_i2s (&id));
3965 #endif
3966       GNUNET_STATISTICS_update (stats,
3967                                 gettext_noop ("# peer addresses not validated (in progress)"),
3968                                 1,
3969                                 GNUNET_NO);
3970       return GNUNET_OK;
3971     }
3972   va = GNUNET_malloc (sizeof (struct ValidationEntry) + addrlen);
3973   va->chvc = chvc;
3974   chvc->ve_count++;
3975   va->transport_name = GNUNET_strdup (tname);
3976   va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
3977                                             UINT_MAX);
3978   va->send_time = GNUNET_TIME_absolute_get();
3979   va->addr = (const void*) &va[1];
3980   memcpy (&va[1], addr, addrlen);
3981   va->addrlen = addrlen;
3982   GNUNET_HELLO_get_key (chvc->hello,
3983                         &va->publicKey);
3984   va->timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
3985                                                    HELLO_VERIFICATION_TIMEOUT,
3986                                                    &timeout_hello_validation,
3987                                                    va);
3988   GNUNET_CONTAINER_multihashmap_put (validation_map,
3989                                      &id.hashPubKey,
3990                                      va,
3991                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3992   setup_peer_check_blacklist (&id, GNUNET_NO,
3993                               &transmit_hello_and_ping,
3994                               va);
3995   return GNUNET_OK;
3996 }
3997
3998
3999 /**
4000  * Check if addresses in validated hello "h" overlap with
4001  * those in "chvc->hello" and validate the rest.
4002  *
4003  * @param cls closure
4004  * @param peer id of the peer, NULL for last call
4005  * @param h hello message for the peer (can be NULL)
4006  */
4007 static void
4008 check_hello_validated (void *cls,
4009                        const struct GNUNET_PeerIdentity *peer,
4010                        const struct GNUNET_HELLO_Message *h)
4011 {
4012   struct CheckHelloValidatedContext *chvc = cls;
4013   struct GNUNET_HELLO_Message *plain_hello;
4014   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk;
4015   struct GNUNET_PeerIdentity target;
4016   struct NeighbourList *n;
4017
4018   if (peer == NULL)
4019     {
4020       GNUNET_STATISTICS_update (stats,
4021                                 gettext_noop ("# outstanding peerinfo iterate requests"),
4022                                 -1,
4023                                 GNUNET_NO);
4024       chvc->piter = NULL;
4025       if (GNUNET_NO == chvc->hello_known)
4026         {
4027           /* notify PEERINFO about the peer now, so that we at least
4028              have the public key if some other component needs it */
4029           GNUNET_HELLO_get_key (chvc->hello, &pk);
4030           GNUNET_CRYPTO_hash (&pk,
4031                               sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4032                               &target.hashPubKey);
4033           plain_hello = GNUNET_HELLO_create (&pk,
4034                                              NULL,
4035                                              NULL);
4036           GNUNET_PEERINFO_add_peer (peerinfo, plain_hello);
4037           GNUNET_free (plain_hello);
4038 #if DEBUG_TRANSPORT_HELLO
4039           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4040                       "PEERINFO had no `%s' message for peer `%4s', full validation needed.\n",
4041                       "HELLO",
4042                       GNUNET_i2s (&target));
4043 #endif
4044           GNUNET_STATISTICS_update (stats,
4045                                     gettext_noop ("# new HELLOs requiring full validation"),
4046                                     1,
4047                                     GNUNET_NO);
4048           GNUNET_HELLO_iterate_addresses (chvc->hello,
4049                                           GNUNET_NO,
4050                                           &run_validation,
4051                                           chvc);
4052         }
4053       else
4054         {
4055           GNUNET_STATISTICS_update (stats,
4056                                     gettext_noop ("# duplicate HELLO (peer known)"),
4057                                     1,
4058                                     GNUNET_NO);
4059         }
4060       chvc->ve_count--;
4061       if (chvc->ve_count == 0)
4062         {
4063           GNUNET_CONTAINER_DLL_remove (chvc_head,
4064                                        chvc_tail,
4065                                        chvc);
4066           GNUNET_free (chvc);
4067         }
4068       return;
4069     }
4070   if (h == NULL)
4071     return;
4072 #if DEBUG_TRANSPORT_HELLO
4073   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4074               "PEERINFO had `%s' message for peer `%4s', validating only new addresses.\n",
4075               "HELLO",
4076               GNUNET_i2s (peer));
4077 #endif
4078   chvc->hello_known = GNUNET_YES;
4079   n = find_neighbour (peer);
4080   if (n != NULL)
4081     {
4082 #if DEBUG_TRANSPORT_HELLO
4083       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4084                   "Calling hello_iterate_addresses for %s!\n",
4085                   GNUNET_i2s (peer));
4086 #endif
4087       GNUNET_HELLO_iterate_addresses (h,
4088                                       GNUNET_NO,
4089                                       &add_to_foreign_address_list,
4090                                       n);
4091       try_transmission_to_peer (n);
4092     }
4093   else
4094     {
4095 #if DEBUG_TRANSPORT_HELLO
4096       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4097                   "No existing neighbor record for %s!\n",
4098                   GNUNET_i2s (peer));
4099 #endif
4100       GNUNET_STATISTICS_update (stats,
4101                                 gettext_noop ("# no existing neighbour record (validating HELLO)"),
4102                                 1,
4103                                 GNUNET_NO);
4104     }
4105   GNUNET_STATISTICS_update (stats,
4106                             gettext_noop ("# HELLO validations (update case)"),
4107                             1,
4108                             GNUNET_NO);
4109   GNUNET_HELLO_iterate_new_addresses (chvc->hello,
4110                                       h,
4111                                       GNUNET_TIME_relative_to_absolute (HELLO_REVALIDATION_START_TIME),
4112                                       &run_validation,
4113                                       chvc);
4114 }
4115
4116
4117 /**
4118  * Process HELLO-message.
4119  *
4120  * @param plugin transport involved, may be NULL
4121  * @param message the actual message
4122  * @return GNUNET_OK if the HELLO was well-formed, GNUNET_SYSERR otherwise
4123  */
4124 static int
4125 process_hello (struct TransportPlugin *plugin,
4126                const struct GNUNET_MessageHeader *message)
4127 {
4128   uint16_t hsize;
4129   struct GNUNET_PeerIdentity target;
4130   const struct GNUNET_HELLO_Message *hello;
4131   struct CheckHelloValidatedContext *chvc;
4132   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
4133 #if DEBUG_TRANSPORT_HELLO > 2
4134   char *my_id;
4135 #endif
4136   hsize = ntohs (message->size);
4137   if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_HELLO) ||
4138       (hsize < sizeof (struct GNUNET_MessageHeader)))
4139     {
4140       GNUNET_break (0);
4141       return GNUNET_SYSERR;
4142     }
4143   GNUNET_STATISTICS_update (stats,
4144                             gettext_noop ("# HELLOs received for validation"),
4145                             1,
4146                             GNUNET_NO);
4147
4148   /* first, check if load is too high */
4149   if (GNUNET_SCHEDULER_get_load (sched,
4150                                  GNUNET_SCHEDULER_PRIORITY_BACKGROUND) > MAX_HELLO_LOAD)
4151     {
4152       GNUNET_STATISTICS_update (stats,
4153                                 gettext_noop ("# HELLOs ignored due to high load"),
4154                                 1,
4155                                 GNUNET_NO);
4156 #if DEBUG_TRANSPORT_HELLO
4157       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4158                   "Ignoring `%s' for `%4s', load too high.\n",
4159                   "HELLO",
4160                   GNUNET_i2s (&target));
4161 #endif
4162       return GNUNET_OK;
4163     }
4164   hello = (const struct GNUNET_HELLO_Message *) message;
4165   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, &publicKey))
4166     {
4167 #if DEBUG_TRANSPORT_HELLO
4168       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4169                   "Unable to get public key from `%s' for `%4s'!\n",
4170                   "HELLO",
4171                   GNUNET_i2s (&target));
4172 #endif
4173       GNUNET_break_op (0);
4174       return GNUNET_SYSERR;
4175     }
4176
4177   GNUNET_CRYPTO_hash (&publicKey,
4178                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4179                       &target.hashPubKey);
4180
4181 #if DEBUG_TRANSPORT_HELLO
4182   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4183               "Received `%s' message for `%4s'\n",
4184               "HELLO",
4185               GNUNET_i2s (&target));
4186 #endif
4187
4188   if (0 == memcmp (&my_identity,
4189                    &target,
4190                    sizeof (struct GNUNET_PeerIdentity)))
4191     {
4192       GNUNET_STATISTICS_update (stats,
4193                                 gettext_noop ("# HELLOs ignored for validation (is my own HELLO)"),
4194                                 1,
4195                                 GNUNET_NO);
4196       return GNUNET_OK;
4197     }
4198   chvc = chvc_head;
4199   while (NULL != chvc)
4200     {
4201       if (GNUNET_HELLO_equals (hello,
4202                                chvc->hello,
4203                                GNUNET_TIME_absolute_get ()).abs_value > 0)
4204         {
4205 #if DEBUG_TRANSPORT_HELLO > 2
4206           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4207                       "Received duplicate `%s' message for `%4s'; ignored\n",
4208                       "HELLO",
4209                       GNUNET_i2s (&target));
4210 #endif
4211           return GNUNET_OK; /* validation already pending */
4212         }
4213       if (GNUNET_HELLO_size(hello) == GNUNET_HELLO_size (chvc->hello))
4214         GNUNET_break (0 != memcmp (hello, chvc->hello,
4215                                    GNUNET_HELLO_size(hello)));
4216       chvc = chvc->next;
4217     }
4218
4219 #if BREAK_TESTS
4220   struct NeighbourList *temp_neighbor = find_neighbour(&target);
4221   if ((NULL != temp_neighbor))
4222     {
4223       fprintf(stderr, "Already know peer, ignoring hello\n");
4224       return GNUNET_OK;
4225     }
4226 #endif
4227
4228 #if DEBUG_TRANSPORT_HELLO > 2
4229   if (plugin != NULL)
4230     {
4231       my_id = GNUNET_strdup(GNUNET_i2s(plugin->env.my_identity));
4232       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4233                   "%s: Starting validation of `%s' message for `%4s' via '%s' of size %u\n",
4234                   my_id,
4235                   "HELLO",
4236                   GNUNET_i2s (&target),
4237                   plugin->short_name,
4238                   GNUNET_HELLO_size(hello));
4239       GNUNET_free(my_id);
4240     }
4241 #endif
4242   chvc = GNUNET_malloc (sizeof (struct CheckHelloValidatedContext) + hsize);
4243   chvc->ve_count = 1;
4244   chvc->hello = (const struct GNUNET_HELLO_Message *) &chvc[1];
4245   memcpy (&chvc[1], hello, hsize);
4246   GNUNET_CONTAINER_DLL_insert (chvc_head,
4247                                chvc_tail,
4248                                chvc);
4249   /* finally, check if HELLO was previously validated
4250      (continuation will then schedule actual validation) */
4251   GNUNET_STATISTICS_update (stats,
4252                             gettext_noop ("# peerinfo process hello iterate requests"),
4253                             1,
4254                             GNUNET_NO);
4255   GNUNET_STATISTICS_update (stats,
4256                             gettext_noop ("# outstanding peerinfo iterate requests"),
4257                             1,
4258                             GNUNET_NO);
4259   chvc->piter = GNUNET_PEERINFO_iterate (peerinfo,
4260                                          &target,
4261                                          HELLO_VERIFICATION_TIMEOUT,
4262                                          &check_hello_validated, chvc);
4263   return GNUNET_OK;
4264 }
4265
4266
4267 /**
4268  * The peer specified by the given neighbour has timed-out or a plugin
4269  * has disconnected.  We may either need to do nothing (other plugins
4270  * still up), or trigger a full disconnect and clean up.  This
4271  * function updates our state and does the necessary notifications.
4272  * Also notifies our clients that the neighbour is now officially
4273  * gone.
4274  *
4275  * @param n the neighbour list entry for the peer
4276  * @param check GNUNET_YES to check if ALL addresses for this peer
4277  *              are gone, GNUNET_NO to force a disconnect of the peer
4278  *              regardless of whether other addresses exist.
4279  */
4280 static void
4281 disconnect_neighbour (struct NeighbourList *n, int check)
4282 {
4283   struct ReadyList *rpos;
4284   struct NeighbourList *npos;
4285   struct NeighbourList *nprev;
4286   struct MessageQueue *mq;
4287   struct ForeignAddressList *peer_addresses;
4288   struct ForeignAddressList *peer_pos;
4289
4290   if (GNUNET_YES == check)
4291     {
4292       rpos = n->plugins;
4293       while (NULL != rpos)
4294         {
4295           peer_addresses = rpos->addresses;
4296           while (peer_addresses != NULL)
4297             {
4298               if (GNUNET_YES == peer_addresses->connected)
4299                 {
4300                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4301                             "NOT Disconnecting from `%4s', still have live addresses!\n",
4302                             GNUNET_i2s (&n->id));
4303                   return;             /* still connected */
4304                 }
4305               peer_addresses = peer_addresses->next;
4306             }
4307           rpos = rpos->next;
4308         }
4309     }
4310 #if DEBUG_TRANSPORT
4311   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
4312               "Disconnecting from `%4s'\n",
4313               GNUNET_i2s (&n->id));
4314 #endif
4315   /* remove n from neighbours list */
4316   nprev = NULL;
4317   npos = neighbours;
4318   while ((npos != NULL) && (npos != n))
4319     {
4320       nprev = npos;
4321       npos = npos->next;
4322     }
4323   GNUNET_assert (npos != NULL);
4324   if (nprev == NULL)
4325     neighbours = n->next;
4326   else
4327     nprev->next = n->next;
4328
4329   /* notify all clients about disconnect */
4330   if (GNUNET_YES == n->received_pong)
4331     notify_clients_disconnect (&n->id);
4332
4333   /* clean up all plugins, cancel connections and pending transmissions */
4334   while (NULL != (rpos = n->plugins))
4335     {
4336       n->plugins = rpos->next;
4337       rpos->plugin->api->disconnect (rpos->plugin->api->cls, &n->id);
4338       while (rpos->addresses != NULL)
4339         {
4340           peer_pos = rpos->addresses;
4341           rpos->addresses = peer_pos->next;
4342           if (peer_pos->connected == GNUNET_YES)
4343             GNUNET_STATISTICS_update (stats,
4344                                       gettext_noop ("# connected addresses"),
4345                                       -1,
4346                                       GNUNET_NO);
4347           if (GNUNET_YES == peer_pos->validated)
4348             GNUNET_STATISTICS_update (stats,
4349                                       gettext_noop ("# peer addresses considered valid"),
4350                                       -1,
4351                                       GNUNET_NO);
4352           if (GNUNET_SCHEDULER_NO_TASK != peer_pos->revalidate_task)
4353             {
4354               GNUNET_SCHEDULER_cancel (sched,
4355                                        peer_pos->revalidate_task);
4356               peer_pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
4357             }
4358           GNUNET_free(peer_pos);
4359         }
4360       GNUNET_free (rpos);
4361     }
4362
4363   /* free all messages on the queue */
4364   while (NULL != (mq = n->messages_head))
4365     {
4366       GNUNET_STATISTICS_update (stats,
4367                                 gettext_noop ("# bytes in message queue for other peers"),
4368                                 - (int64_t) mq->message_buf_size,
4369                                 GNUNET_NO);
4370       GNUNET_STATISTICS_update (stats,
4371                                 gettext_noop ("# bytes discarded due to disconnect"),
4372                                 mq->message_buf_size,
4373                                 GNUNET_NO);
4374       GNUNET_CONTAINER_DLL_remove (n->messages_head,
4375                                    n->messages_tail,
4376                                    mq);
4377       GNUNET_assert (0 == memcmp(&mq->neighbour_id,
4378                                  &n->id,
4379                                  sizeof(struct GNUNET_PeerIdentity)));
4380       GNUNET_free (mq);
4381     }
4382   if (n->timeout_task != GNUNET_SCHEDULER_NO_TASK)
4383     {
4384       GNUNET_SCHEDULER_cancel (sched, n->timeout_task);
4385       n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
4386     }
4387   if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
4388     {
4389       GNUNET_SCHEDULER_cancel (sched, n->retry_task);
4390       n->retry_task = GNUNET_SCHEDULER_NO_TASK;
4391     }
4392   if (n->piter != NULL)
4393     {
4394       GNUNET_PEERINFO_iterate_cancel (n->piter);
4395       GNUNET_STATISTICS_update (stats,
4396                                 gettext_noop ("# outstanding peerinfo iterate requests"),
4397                                 -1,
4398                                 GNUNET_NO);
4399       n->piter = NULL;
4400     }
4401   /* finally, free n itself */
4402   GNUNET_STATISTICS_update (stats,
4403                             gettext_noop ("# active neighbours"),
4404                             -1,
4405                             GNUNET_NO);
4406   GNUNET_free_non_null (n->pre_connect_message_buffer);
4407   GNUNET_free (n);
4408 }
4409
4410
4411 /**
4412  * We have received a PING message from someone.  Need to send a PONG message
4413  * in response to the peer by any means necessary.
4414  */
4415 static int
4416 handle_ping(void *cls, const struct GNUNET_MessageHeader *message,
4417             const struct GNUNET_PeerIdentity *peer,
4418             struct Session *session,
4419             const char *sender_address,
4420             uint16_t sender_address_len)
4421 {
4422   struct TransportPlugin *plugin = cls;
4423   struct SessionHeader *session_header = (struct SessionHeader*) session;
4424   struct TransportPingMessage *ping;
4425   struct TransportPongMessage *pong;
4426   struct NeighbourList *n;
4427   struct ReadyList *rl;
4428   struct ForeignAddressList *fal;
4429   struct OwnAddressList *oal;
4430   const char *addr;
4431   size_t alen;
4432   size_t slen;
4433
4434   if (ntohs (message->size) < sizeof (struct TransportPingMessage))
4435     {
4436       GNUNET_break_op (0);
4437       return GNUNET_SYSERR;
4438     }
4439
4440   ping = (struct TransportPingMessage *) message;
4441   if (0 != memcmp (&ping->target,
4442                    plugin->env.my_identity,
4443                    sizeof (struct GNUNET_PeerIdentity)))
4444     {
4445       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
4446                   _("Received `%s' message from `%s' destined for `%s' which is not me!\n"),
4447                   "PING",
4448                   (sender_address != NULL)
4449                   ? a2s (plugin->short_name,
4450                          (const struct sockaddr *)sender_address,
4451                          sender_address_len)
4452                   : "<inbound>",
4453                   GNUNET_i2s (&ping->target));
4454       return GNUNET_SYSERR;
4455     }
4456 #if DEBUG_PING_PONG
4457   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
4458               "Processing `%s' from `%s'\n",
4459               "PING",
4460               (sender_address != NULL)
4461               ? a2s (plugin->short_name,
4462                      (const struct sockaddr *)sender_address,
4463                      sender_address_len)
4464               : "<inbound>");
4465 #endif
4466   GNUNET_STATISTICS_update (stats,
4467                             gettext_noop ("# PING messages received"),
4468                             1,
4469                             GNUNET_NO);
4470   addr = (const char*) &ping[1];
4471   alen = ntohs (message->size) - sizeof (struct TransportPingMessage);
4472   slen = strlen (plugin->short_name) + 1;
4473   if (alen == 0)
4474     {
4475       /* peer wants to confirm that we have an outbound connection to him */
4476       if (session == NULL)
4477         {
4478           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4479                       _("Refusing to create PONG since I do not have a session with `%s'.\n"),
4480                       GNUNET_i2s (peer));
4481           return GNUNET_SYSERR;
4482         }
4483       pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + sender_address_len + slen);
4484       pong->header.size = htons (sizeof (struct TransportPongMessage) + sender_address_len + slen);
4485       pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
4486       pong->purpose.size =
4487         htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
4488                sizeof (uint32_t) +
4489                sizeof (struct GNUNET_TIME_AbsoluteNBO) +
4490                sizeof (struct GNUNET_PeerIdentity) + sender_address_len + slen);
4491       pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING);
4492       pong->challenge = ping->challenge;
4493       pong->addrlen = htonl(sender_address_len + slen);
4494       memcpy(&pong->pid,
4495              peer,
4496              sizeof(struct GNUNET_PeerIdentity));
4497       memcpy (&pong[1],
4498               plugin->short_name,
4499               slen);
4500       memcpy (&((char*)&pong[1])[slen],
4501               sender_address,
4502               sender_address_len);
4503       if (GNUNET_TIME_absolute_get_remaining (session_header->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4)
4504         {
4505           /* create / update cached sig */
4506 #if DEBUG_TRANSPORT
4507           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4508                       "Creating PONG signature to indicate active connection.\n");
4509 #endif
4510           session_header->pong_sig_expires = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
4511           pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
4512           GNUNET_assert (GNUNET_OK ==
4513                          GNUNET_CRYPTO_rsa_sign (my_private_key,
4514                                                  &pong->purpose,
4515                                                  &session_header->pong_signature));
4516         }
4517       else
4518         {
4519           pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
4520         }
4521       memcpy (&pong->signature,
4522               &session_header->pong_signature,
4523               sizeof (struct GNUNET_CRYPTO_RsaSignature));
4524
4525
4526     }
4527   else
4528     {
4529       /* peer wants to confirm that this is one of our addresses */
4530       addr += slen;
4531       alen -= slen;
4532       if (GNUNET_OK !=
4533           plugin->api->check_address (plugin->api->cls,
4534                                       addr,
4535                                       alen))
4536         {
4537           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4538                       _("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
4539                       a2s (plugin->short_name,
4540                            addr,
4541                            alen));
4542           return GNUNET_NO;
4543         }
4544       oal = plugin->addresses;
4545       while (NULL != oal)
4546         {
4547           if ( (oal->addrlen == alen) &&
4548                (0 == memcmp (addr,
4549                              &oal[1],
4550                              alen)) )
4551             break;
4552           oal = oal->next;
4553         }
4554       pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + alen + slen);
4555       pong->header.size = htons (sizeof (struct TransportPongMessage) + alen + slen);
4556       pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
4557       pong->purpose.size =
4558         htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
4559                sizeof (uint32_t) +
4560                sizeof (struct GNUNET_TIME_AbsoluteNBO) +
4561                sizeof (struct GNUNET_PeerIdentity) + alen + slen);
4562       pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN);
4563       pong->challenge = ping->challenge;
4564       pong->addrlen = htonl(alen + slen);
4565       memcpy(&pong->pid,
4566              &my_identity,
4567              sizeof(struct GNUNET_PeerIdentity));
4568       memcpy (&pong[1], plugin->short_name, slen);
4569       memcpy (&((char*)&pong[1])[slen], addr, alen);
4570       if ( (oal != NULL) &&
4571            (GNUNET_TIME_absolute_get_remaining (oal->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4) )
4572         {
4573           /* create / update cached sig */
4574 #if DEBUG_TRANSPORT
4575           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4576                       "Creating PONG signature to indicate ownership.\n");
4577 #endif
4578           oal->pong_sig_expires = GNUNET_TIME_absolute_min (oal->expires,
4579                                                             GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
4580           pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
4581           GNUNET_assert (GNUNET_OK ==
4582                          GNUNET_CRYPTO_rsa_sign (my_private_key,
4583                                                  &pong->purpose,
4584                                                  &oal->pong_signature));
4585           memcpy (&pong->signature,
4586                   &oal->pong_signature,
4587                   sizeof (struct GNUNET_CRYPTO_RsaSignature));
4588         }
4589       else if (oal == NULL)
4590         {
4591           /* not using cache (typically DV-only) */
4592           pong->expiration = GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
4593           GNUNET_assert (GNUNET_OK ==
4594                          GNUNET_CRYPTO_rsa_sign (my_private_key,
4595                                                  &pong->purpose,
4596                                                  &pong->signature));
4597         }
4598       else
4599         {
4600           /* can used cached version */
4601           pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
4602           memcpy (&pong->signature,
4603                   &oal->pong_signature,
4604                   sizeof (struct GNUNET_CRYPTO_RsaSignature));
4605         }
4606     }
4607   n = find_neighbour(peer);
4608   GNUNET_assert (n != NULL);
4609   /* first try reliable response transmission */
4610   rl = n->plugins;
4611   while (rl != NULL)
4612     {
4613       fal = rl->addresses;
4614       while (fal != NULL)
4615         {
4616           if (-1 != rl->plugin->api->send (rl->plugin->api->cls,
4617                                            peer,
4618                                            (const char*) pong,
4619                                            ntohs (pong->header.size),
4620                                            TRANSPORT_PONG_PRIORITY,
4621                                            HELLO_VERIFICATION_TIMEOUT,
4622                                            fal->session,
4623                                            fal->addr,
4624                                            fal->addrlen,
4625                                            GNUNET_SYSERR,
4626                                            NULL, NULL))
4627             {
4628               /* done! */
4629               GNUNET_STATISTICS_update (stats,
4630                                         gettext_noop ("# PONGs unicast via reliable transport"),
4631                                         1,
4632                                         GNUNET_NO);
4633               GNUNET_free (pong);
4634               return GNUNET_OK;
4635             }
4636           fal = fal->next;
4637         }
4638       rl = rl->next;
4639     }
4640   /* no reliable method found, do multicast */
4641   GNUNET_STATISTICS_update (stats,
4642                             gettext_noop ("# PONGs multicast to all available addresses"),
4643                             1,
4644                             GNUNET_NO);
4645   rl = n->plugins;
4646   while (rl != NULL)
4647     {
4648       fal = rl->addresses;
4649       while (fal != NULL)
4650         {
4651           transmit_to_peer(NULL, fal,
4652                            TRANSPORT_PONG_PRIORITY,
4653                            HELLO_VERIFICATION_TIMEOUT,
4654                            (const char *)pong,
4655                            ntohs(pong->header.size),
4656                            GNUNET_YES,
4657                            n);
4658           fal = fal->next;
4659         }
4660       rl = rl->next;
4661     }
4662   GNUNET_free(pong);
4663   return GNUNET_OK;
4664 }
4665
4666
4667 /**
4668  * Function called by the plugin for each received message.
4669  * Update data volumes, possibly notify plugins about
4670  * reducing the rate at which they read from the socket
4671  * and generally forward to our receive callback.
4672  *
4673  * @param cls the "struct TransportPlugin *" we gave to the plugin
4674  * @param peer (claimed) identity of the other peer
4675  * @param message the message, NULL if we only care about
4676  *                learning about the delay until we should receive again
4677  * @param distance in overlay hops; use 1 unless DV (or 0 if message == NULL)
4678  * @param session identifier used for this session (can be NULL)
4679  * @param sender_address binary address of the sender (if observed)
4680  * @param sender_address_len number of bytes in sender_address
4681  * @return how long in ms the plugin should wait until receiving more data
4682  *         (plugins that do not support this, can ignore the return value)
4683  */
4684 static struct GNUNET_TIME_Relative
4685 plugin_env_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
4686                     const struct GNUNET_MessageHeader *message,
4687                     uint32_t distance,
4688                     struct Session *session,
4689                     const char *sender_address,
4690                     uint16_t sender_address_len)
4691 {
4692   struct TransportPlugin *plugin = cls;
4693   struct ReadyList *service_context;
4694   struct ForeignAddressList *peer_address;
4695   uint16_t msize;
4696   struct NeighbourList *n;
4697   struct GNUNET_TIME_Relative ret;
4698   if (is_blacklisted (peer, plugin))
4699     return GNUNET_TIME_UNIT_FOREVER_REL;
4700
4701   n = find_neighbour (peer);
4702   if (n == NULL)
4703     n = setup_new_neighbour (peer, GNUNET_YES);
4704   service_context = n->plugins;
4705   while ((service_context != NULL) && (plugin != service_context->plugin))
4706     service_context = service_context->next;
4707   GNUNET_assert ((plugin->api->send == NULL) || (service_context != NULL));
4708   peer_address = NULL;
4709   if (message != NULL)
4710     {
4711       if ( (session != NULL) ||
4712            (sender_address != NULL) )
4713         peer_address = add_peer_address (n,
4714                                          plugin->short_name,
4715                                          session,
4716                                          sender_address,
4717                                          sender_address_len);
4718       if (peer_address != NULL)
4719         {
4720           peer_address->distance = distance;
4721           if (GNUNET_YES == peer_address->validated)
4722             mark_address_connected (peer_address);
4723           peer_address->timeout
4724             =
4725             GNUNET_TIME_relative_to_absolute
4726             (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
4727           schedule_next_ping (peer_address);
4728         }
4729       /* update traffic received amount ... */
4730       msize = ntohs (message->size);
4731       GNUNET_STATISTICS_update (stats,
4732                                 gettext_noop ("# bytes received from other peers"),
4733                                 msize,
4734                                 GNUNET_NO);
4735       n->distance = distance;
4736       n->peer_timeout =
4737         GNUNET_TIME_relative_to_absolute
4738         (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
4739       GNUNET_SCHEDULER_cancel (sched,
4740                                n->timeout_task);
4741       n->timeout_task =
4742         GNUNET_SCHEDULER_add_delayed (sched,
4743                                       GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
4744                                       &neighbour_timeout_task, n);
4745       if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
4746         {
4747           /* dropping message due to frequent inbound volume violations! */
4748           GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
4749                       GNUNET_ERROR_TYPE_BULK,
4750                       _
4751                       ("Dropping incoming message due to repeated bandwidth quota (%u b/s) violations (total of %u).\n"),
4752                       n->in_tracker.available_bytes_per_s__,
4753                       n->quota_violation_count);
4754           GNUNET_STATISTICS_update (stats,
4755                                     gettext_noop ("# bandwidth quota violations by other peers"),
4756                                     1,
4757                                     GNUNET_NO);
4758           return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
4759         }
4760
4761 #if DEBUG_PING_PONG
4762           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4763                       "Received message of type %u and size %u from `%4s', sending to all clients.\n",
4764                       ntohs (message->type),
4765                       ntohs (message->size),
4766                       GNUNET_i2s (peer));
4767 #endif
4768       switch (ntohs (message->type))
4769         {
4770         case GNUNET_MESSAGE_TYPE_HELLO:
4771           GNUNET_STATISTICS_update (stats,
4772                                     gettext_noop ("# HELLO messages received from other peers"),
4773                                     1,
4774                                     GNUNET_NO);
4775           process_hello (plugin, message);
4776           break;
4777         case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
4778           handle_ping (plugin, message, peer, session, sender_address, sender_address_len);
4779           break;
4780         case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
4781           handle_pong (plugin, message, peer, sender_address, sender_address_len);
4782           break;
4783         default:
4784           handle_payload_message (message, n);
4785           break;
4786         }
4787     }
4788   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 0);
4789   if (ret.rel_value > 0)
4790     {
4791       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4792                   "Throttling read (%llu bytes excess at %u b/s), waiting %llums before reading more.\n",
4793                   (unsigned long long) n->in_tracker.consumption_since_last_update__,
4794                   (unsigned int) n->in_tracker.available_bytes_per_s__,
4795                   (unsigned long long) ret.rel_value);
4796       GNUNET_STATISTICS_update (stats,
4797                                 gettext_noop ("# ms throttling suggested"),
4798                                 (int64_t) ret.rel_value,
4799                                 GNUNET_NO);
4800     }
4801   return ret;
4802 }
4803
4804 /**
4805  * Handle START-message.  This is the first message sent to us
4806  * by any client which causes us to add it to our list.
4807  *
4808  * @param cls closure (always NULL)
4809  * @param client identification of the client
4810  * @param message the actual message
4811  */
4812 static void
4813 handle_start (void *cls,
4814               struct GNUNET_SERVER_Client *client,
4815               const struct GNUNET_MessageHeader *message)
4816 {
4817   const struct StartMessage *start;
4818   struct TransportClient *c;
4819   struct ConnectInfoMessage cim;
4820   struct NeighbourList *n;
4821
4822   start = (const struct StartMessage*) message;
4823 #if DEBUG_TRANSPORT
4824   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4825               "Received `%s' request from client\n", "START");
4826 #endif
4827   c = clients;
4828   while (c != NULL)
4829     {
4830       if (c->client == client)
4831         {
4832           /* client already on our list! */
4833           GNUNET_break (0);
4834           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4835           return;
4836         }
4837       c = c->next;
4838     }
4839   if ( (GNUNET_NO != ntohl (start->do_check)) &&
4840        (0 != memcmp (&start->self,
4841                      &my_identity,
4842                      sizeof (struct GNUNET_PeerIdentity))) )
4843     {
4844       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
4845                   _("Rejecting control connection from peer `%s', which is not me!\n"),
4846                   GNUNET_i2s (&start->self));
4847       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4848       return;
4849     }
4850   c = GNUNET_malloc (sizeof (struct TransportClient));
4851   c->next = clients;
4852   clients = c;
4853   c->client = client;
4854   if (our_hello != NULL)
4855     {
4856 #if DEBUG_TRANSPORT
4857       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4858                   "Sending our own `%s' to new client\n", "HELLO");
4859 #endif
4860       transmit_to_client (c,
4861                           (const struct GNUNET_MessageHeader *) our_hello,
4862                           GNUNET_NO);
4863       /* tell new client about all existing connections */
4864       cim.header.size = htons (sizeof (struct ConnectInfoMessage));
4865       cim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
4866       n = neighbours;
4867       while (n != NULL)
4868         {
4869           if (GNUNET_YES == n->received_pong)
4870             {
4871               cim.id = n->id;
4872               cim.latency = GNUNET_TIME_relative_hton (n->latency);
4873               cim.distance = htonl (n->distance);
4874               transmit_to_client (c, &cim.header, GNUNET_NO);
4875             }
4876             n = n->next;
4877         }
4878     }
4879   GNUNET_SERVER_receive_done (client, GNUNET_OK);
4880 }
4881
4882
4883 /**
4884  * Handle HELLO-message.
4885  *
4886  * @param cls closure (always NULL)
4887  * @param client identification of the client
4888  * @param message the actual message
4889  */
4890 static void
4891 handle_hello (void *cls,
4892               struct GNUNET_SERVER_Client *client,
4893               const struct GNUNET_MessageHeader *message)
4894 {
4895   int ret;
4896
4897   GNUNET_STATISTICS_update (stats,
4898                             gettext_noop ("# HELLOs received from clients"),
4899                             1,
4900                             GNUNET_NO);
4901   ret = process_hello (NULL, message);
4902   GNUNET_SERVER_receive_done (client, ret);
4903 }
4904
4905
4906 /**
4907  * Closure for 'transmit_client_message'; followed by
4908  * 'msize' bytes of the actual message.
4909  */
4910 struct TransmitClientMessageContext
4911 {
4912   /**
4913    * Client on whom's behalf we are sending.
4914    */
4915   struct GNUNET_SERVER_Client *client;
4916
4917   /**
4918    * Timeout for the transmission.
4919    */
4920   struct GNUNET_TIME_Absolute timeout;
4921
4922   /**
4923    * Message priority.
4924    */
4925   uint32_t priority;
4926
4927   /**
4928    * Size of the message in bytes.
4929    */
4930   uint16_t msize;
4931 };
4932
4933
4934 /**
4935  * Schedule transmission of a message we got from a client to a peer.
4936  *
4937  * @param cls the 'struct TransmitClientMessageContext*'
4938  * @param n destination, or NULL on error (in that case, drop the message)
4939  */
4940 static void
4941 transmit_client_message (void *cls,
4942                          struct NeighbourList *n)
4943 {
4944   struct TransmitClientMessageContext *tcmc = cls;
4945   struct TransportClient *tc;
4946
4947   tc = clients;
4948   while ((tc != NULL) && (tc->client != tcmc->client))
4949     tc = tc->next;
4950
4951   if (n != NULL)
4952     {
4953       transmit_to_peer (tc, NULL, tcmc->priority,
4954                         GNUNET_TIME_absolute_get_remaining (tcmc->timeout),
4955                         (char *)&tcmc[1],
4956                         tcmc->msize, GNUNET_NO, n);
4957     }
4958   GNUNET_SERVER_receive_done (tcmc->client, GNUNET_OK);
4959   GNUNET_SERVER_client_drop (tcmc->client);
4960   GNUNET_free (tcmc);
4961 }
4962
4963
4964 /**
4965  * Handle SEND-message.
4966  *
4967  * @param cls closure (always NULL)
4968  * @param client identification of the client
4969  * @param message the actual message
4970  */
4971 static void
4972 handle_send (void *cls,
4973              struct GNUNET_SERVER_Client *client,
4974              const struct GNUNET_MessageHeader *message)
4975 {
4976   const struct OutboundMessage *obm;
4977   const struct GNUNET_MessageHeader *obmm;
4978   struct TransmitClientMessageContext *tcmc;
4979   uint16_t size;
4980   uint16_t msize;
4981
4982   size = ntohs (message->size);
4983   if (size <
4984       sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
4985     {
4986       GNUNET_break (0);
4987       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
4988       return;
4989     }
4990   GNUNET_STATISTICS_update (stats,
4991                             gettext_noop ("# payload received for other peers"),
4992                             size,
4993                             GNUNET_NO);
4994   obm = (const struct OutboundMessage *) message;
4995   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
4996   msize = size - sizeof (struct OutboundMessage);
4997
4998   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4999               "Received `%s' request from client with target `%4s' and message of type %u and size %u\n",
5000               "SEND", GNUNET_i2s (&obm->peer),
5001               ntohs (obmm->type),
5002               msize);
5003
5004   tcmc = GNUNET_malloc (sizeof (struct TransmitClientMessageContext) + msize);
5005   tcmc->client = client;
5006   tcmc->priority = ntohl (obm->priority);
5007   tcmc->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh (obm->timeout));
5008   tcmc->msize = msize;
5009   /* FIXME: this memcpy can be up to 7% of our total runtime */
5010   memcpy (&tcmc[1], obmm, msize);
5011   GNUNET_SERVER_client_keep (client);
5012   setup_peer_check_blacklist (&obm->peer, GNUNET_YES,
5013                               &transmit_client_message,
5014                               tcmc);
5015 }
5016
5017
5018 /**
5019  * Handle request connect message
5020  *
5021  * @param cls closure (always NULL)
5022  * @param client identification of the client
5023  * @param message the actual message
5024  */
5025 static void
5026 handle_request_connect (void *cls,
5027                         struct GNUNET_SERVER_Client *client,
5028                         const struct GNUNET_MessageHeader *message)
5029 {
5030   const struct TransportRequestConnectMessage *trcm =
5031     (const struct TransportRequestConnectMessage *) message;
5032
5033   GNUNET_STATISTICS_update (stats,
5034                             gettext_noop ("# REQUEST CONNECT messages received"),
5035                             1,
5036                             GNUNET_NO);
5037   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received a request connect message for peer %s\n", GNUNET_i2s(&trcm->peer));
5038   setup_peer_check_blacklist (&trcm->peer, GNUNET_YES,
5039                               NULL, NULL);
5040   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5041 }
5042
5043 /**
5044  * Handle SET_QUOTA-message.
5045  *
5046  * @param cls closure (always NULL)
5047  * @param client identification of the client
5048  * @param message the actual message
5049  */
5050 static void
5051 handle_set_quota (void *cls,
5052                   struct GNUNET_SERVER_Client *client,
5053                   const struct GNUNET_MessageHeader *message)
5054 {
5055   const struct QuotaSetMessage *qsm =
5056     (const struct QuotaSetMessage *) message;
5057   struct NeighbourList *n;
5058
5059   GNUNET_STATISTICS_update (stats,
5060                             gettext_noop ("# SET QUOTA messages received"),
5061                             1,
5062                             GNUNET_NO);
5063   n = find_neighbour (&qsm->peer);
5064   if (n == NULL)
5065     {
5066       GNUNET_SERVER_receive_done (client, GNUNET_OK);
5067       GNUNET_STATISTICS_update (stats,
5068                                 gettext_noop ("# SET QUOTA messages ignored (no such peer)"),
5069                                 1,
5070                                 GNUNET_NO);
5071       return;
5072     }
5073 #if DEBUG_TRANSPORT
5074   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5075               "Received `%s' request (new quota %u, old quota %u) from client for peer `%4s'\n",
5076               "SET_QUOTA",
5077               (unsigned int) ntohl (qsm->quota.value__),
5078               (unsigned int) n->in_tracker.available_bytes_per_s__,
5079               GNUNET_i2s (&qsm->peer));
5080 #endif
5081   GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker,
5082                                          qsm->quota);
5083   if (0 == ntohl (qsm->quota.value__))
5084     {
5085       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5086                 "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&n->id),
5087                 "SET_QUOTA");
5088       disconnect_neighbour (n, GNUNET_NO);
5089     }
5090   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5091 }
5092
5093
5094 /**
5095  * Take the given address and append it to the set of results sent back to
5096  * the client.
5097  *
5098  * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
5099  * @param address the resolved name, NULL to indicate the last response
5100  */
5101 static void
5102 transmit_address_to_client (void *cls, const char *address)
5103 {
5104   struct GNUNET_SERVER_TransmitContext *tc = cls;
5105   size_t slen;
5106
5107   if (NULL == address)
5108     slen = 0;
5109   else
5110     slen = strlen (address) + 1;
5111
5112   GNUNET_SERVER_transmit_context_append_data (tc, address, slen,
5113                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
5114   if (NULL == address)
5115     GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
5116 }
5117
5118
5119 /**
5120  * Handle AddressLookup-message.
5121  *
5122  * @param cls closure (always NULL)
5123  * @param client identification of the client
5124  * @param message the actual message
5125  */
5126 static void
5127 handle_address_lookup (void *cls,
5128                        struct GNUNET_SERVER_Client *client,
5129                        const struct GNUNET_MessageHeader *message)
5130 {
5131   const struct AddressLookupMessage *alum;
5132   struct TransportPlugin *lsPlugin;
5133   const char *nameTransport;
5134   const char *address;
5135   uint16_t size;
5136   struct GNUNET_SERVER_TransmitContext *tc;
5137   struct GNUNET_TIME_Absolute timeout;
5138   struct GNUNET_TIME_Relative rtimeout;
5139   int32_t numeric;
5140
5141   size = ntohs (message->size);
5142   if (size < sizeof (struct AddressLookupMessage))
5143     {
5144       GNUNET_break_op (0);
5145       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5146       return;
5147     }
5148   alum = (const struct AddressLookupMessage *) message;
5149   uint32_t addressLen = ntohl (alum->addrlen);
5150   if (size <= sizeof (struct AddressLookupMessage) + addressLen)
5151     {
5152       GNUNET_break_op (0);
5153       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5154       return;
5155     }
5156   address = (const char *) &alum[1];
5157   nameTransport = (const char *) &address[addressLen];
5158   if (nameTransport
5159       [size - sizeof (struct AddressLookupMessage) - addressLen - 1] != '\0')
5160     {
5161       GNUNET_break_op (0);
5162       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5163       return;
5164     }
5165   timeout = GNUNET_TIME_absolute_ntoh (alum->timeout);
5166   rtimeout = GNUNET_TIME_absolute_get_remaining (timeout);
5167   numeric = ntohl (alum->numeric_only);
5168   lsPlugin = find_transport (nameTransport);
5169   if (NULL == lsPlugin)
5170     {
5171       tc = GNUNET_SERVER_transmit_context_create (client);
5172       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
5173                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
5174       GNUNET_SERVER_transmit_context_run (tc, rtimeout);
5175       return;
5176     }
5177   tc = GNUNET_SERVER_transmit_context_create (client);
5178   lsPlugin->api->address_pretty_printer (lsPlugin->api->cls,
5179                                          nameTransport,
5180                                          address, addressLen,
5181                                          numeric,
5182                                          rtimeout,
5183                                          &transmit_address_to_client, tc);
5184 }
5185
5186
5187 /**
5188  * Setup the environment for this plugin.
5189  */
5190 static void
5191 create_environment (struct TransportPlugin *plug)
5192 {
5193   plug->env.cfg = cfg;
5194   plug->env.sched = sched;
5195   plug->env.my_identity = &my_identity;
5196   plug->env.our_hello = &our_hello;
5197   plug->env.cls = plug;
5198   plug->env.receive = &plugin_env_receive;
5199   plug->env.notify_address = &plugin_env_notify_address;
5200   plug->env.session_end = &plugin_env_session_end;
5201   plug->env.max_connections = max_connect_per_transport;
5202   plug->env.stats = stats;
5203 }
5204
5205
5206 /**
5207  * Start the specified transport (load the plugin).
5208  */
5209 static void
5210 start_transport (struct GNUNET_SERVER_Handle *server,
5211                  const char *name)
5212 {
5213   struct TransportPlugin *plug;
5214   char *libname;
5215
5216   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5217               _("Loading `%s' transport plugin\n"), name);
5218   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", name);
5219   plug = GNUNET_malloc (sizeof (struct TransportPlugin));
5220   create_environment (plug);
5221   plug->short_name = GNUNET_strdup (name);
5222   plug->lib_name = libname;
5223   plug->next = plugins;
5224   plugins = plug;
5225   plug->api = GNUNET_PLUGIN_load (libname, &plug->env);
5226   if (plug->api == NULL)
5227     {
5228       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5229                   _("Failed to load transport plugin for `%s'\n"), name);
5230       GNUNET_free (plug->short_name);
5231       plugins = plug->next;
5232       GNUNET_free (libname);
5233       GNUNET_free (plug);
5234     }
5235 }
5236
5237
5238 /**
5239  * Called whenever a client is disconnected.  Frees our
5240  * resources associated with that client.
5241  *
5242  * @param cls closure
5243  * @param client identification of the client
5244  */
5245 static void
5246 client_disconnect_notification (void *cls,
5247                                 struct GNUNET_SERVER_Client *client)
5248 {
5249   struct TransportClient *pos;
5250   struct TransportClient *prev;
5251   struct ClientMessageQueueEntry *mqe;
5252   struct Blacklisters *bl;
5253   struct BlacklistCheck *bc;
5254
5255   if (client == NULL)
5256     return;
5257 #if DEBUG_TRANSPORT
5258   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
5259               "Client disconnected, cleaning up.\n");
5260 #endif
5261   /* clean up blacklister */
5262   bl = bl_head;
5263   while (bl != NULL)
5264     {
5265       if (bl->client == client)
5266         {
5267           bc = bc_head;
5268           while (bc != NULL)
5269             {
5270               if (bc->bl_pos == bl)
5271                 {
5272                   bc->bl_pos = bl->next;
5273                   if (bc->th != NULL)
5274                     {
5275                       GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
5276                       bc->th = NULL;
5277                     }
5278                   if (bc->task == GNUNET_SCHEDULER_NO_TASK)
5279                     bc->task = GNUNET_SCHEDULER_add_now (sched,
5280                                                          &do_blacklist_check,
5281                                                          bc);
5282                   break;
5283                 }
5284               bc = bc->next;
5285             }
5286           GNUNET_CONTAINER_DLL_remove (bl_head,
5287                                        bl_tail,
5288                                        bl);
5289           GNUNET_SERVER_client_drop (bl->client);
5290           GNUNET_free (bl);
5291           break;
5292         }
5293       bl = bl->next;
5294     }
5295   /* clean up 'normal' clients */
5296   prev = NULL;
5297   pos = clients;
5298   while ((pos != NULL) && (pos->client != client))
5299     {
5300       prev = pos;
5301       pos = pos->next;
5302     }
5303   if (pos == NULL)
5304     return;
5305   while (NULL != (mqe = pos->message_queue_head))
5306     {
5307       GNUNET_CONTAINER_DLL_remove (pos->message_queue_head,
5308                                    pos->message_queue_tail,
5309                                    mqe);
5310       pos->message_count--;
5311       GNUNET_free (mqe);
5312     }
5313   if (prev == NULL)
5314     clients = pos->next;
5315   else
5316     prev->next = pos->next;
5317   if (GNUNET_YES == pos->tcs_pending)
5318     {
5319       pos->client = NULL;
5320       return;
5321     }
5322   if (pos->th != NULL)
5323     {
5324       GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
5325       pos->th = NULL;
5326     }
5327   GNUNET_break (0 == pos->message_count);
5328   GNUNET_free (pos);
5329 }
5330
5331
5332 /**
5333  * Function called when the service shuts down.  Unloads our plugins
5334  * and cancels pending validations.
5335  *
5336  * @param cls closure, unused
5337  * @param tc task context (unused)
5338  */
5339 static void
5340 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
5341 {
5342   struct TransportPlugin *plug;
5343   struct OwnAddressList *al;
5344   struct CheckHelloValidatedContext *chvc;
5345
5346   while (neighbours != NULL)
5347     {
5348       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5349               "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&neighbours->id),
5350               "SHUTDOWN_TASK");
5351       disconnect_neighbour (neighbours, GNUNET_NO);
5352     }
5353 #if DEBUG_TRANSPORT
5354   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5355               "Transport service is unloading plugins...\n");
5356 #endif
5357   while (NULL != (plug = plugins))
5358     {
5359       plugins = plug->next;
5360       if (plug->address_update_task != GNUNET_SCHEDULER_NO_TASK)
5361         {
5362           GNUNET_SCHEDULER_cancel (plug->env.sched,
5363                                    plug->address_update_task);
5364           plug->address_update_task = GNUNET_SCHEDULER_NO_TASK;
5365         }
5366       GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
5367       GNUNET_free (plug->lib_name);
5368       GNUNET_free (plug->short_name);
5369       while (NULL != (al = plug->addresses))
5370         {
5371           plug->addresses = al->next;
5372           GNUNET_free (al);
5373         }
5374       GNUNET_free (plug);
5375     }
5376   if (my_private_key != NULL)
5377     GNUNET_CRYPTO_rsa_key_free (my_private_key);
5378   GNUNET_free_non_null (our_hello);
5379
5380   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
5381                                          &abort_validation,
5382                                          NULL);
5383   GNUNET_CONTAINER_multihashmap_destroy (validation_map);
5384   validation_map = NULL;
5385
5386   /* free 'chvc' data structure */
5387   while (NULL != (chvc = chvc_head))
5388     {
5389       chvc_head = chvc->next;
5390       if (chvc->piter != NULL)
5391         {
5392           GNUNET_PEERINFO_iterate_cancel (chvc->piter);
5393           GNUNET_STATISTICS_update (stats,
5394                                     gettext_noop ("# outstanding peerinfo iterate requests"),
5395                                     -1,
5396                                     GNUNET_NO);
5397         }
5398       else
5399         GNUNET_break (0);
5400       GNUNET_assert (chvc->ve_count == 0);
5401       GNUNET_free (chvc);
5402     }
5403   chvc_tail = NULL;
5404
5405   if (stats != NULL)
5406     {
5407       GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
5408       stats = NULL;
5409     }
5410   if (peerinfo != NULL)
5411     {
5412       GNUNET_PEERINFO_disconnect (peerinfo);
5413       peerinfo = NULL;
5414     }
5415   /* Can we assume those are gone by now, or do we need to clean up
5416      explicitly!? */
5417   GNUNET_break (bl_head == NULL);
5418   GNUNET_break (bc_head == NULL);
5419 }
5420
5421
5422 /**
5423  * Initiate transport service.
5424  *
5425  * @param cls closure
5426  * @param s scheduler to use
5427  * @param server the initialized server
5428  * @param c configuration to use
5429  */
5430 static void
5431 run (void *cls,
5432      struct GNUNET_SCHEDULER_Handle *s,
5433      struct GNUNET_SERVER_Handle *server,
5434      const struct GNUNET_CONFIGURATION_Handle *c)
5435 {
5436   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
5437     {&handle_start, NULL,
5438      GNUNET_MESSAGE_TYPE_TRANSPORT_START, sizeof (struct StartMessage)},
5439     {&handle_hello, NULL,
5440      GNUNET_MESSAGE_TYPE_HELLO, 0},
5441     {&handle_send, NULL,
5442      GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0},
5443     {&handle_request_connect, NULL,
5444      GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT, sizeof(struct TransportRequestConnectMessage)},
5445     {&handle_set_quota, NULL,
5446      GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)},
5447     {&handle_address_lookup, NULL,
5448      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP,
5449      0},
5450     {&handle_blacklist_init, NULL,
5451      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, sizeof (struct GNUNET_MessageHeader)},
5452     {&handle_blacklist_reply, NULL,
5453      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, sizeof (struct BlacklistMessage)},
5454     {NULL, NULL, 0, 0}
5455   };
5456   char *plugs;
5457   char *pos;
5458   int no_transports;
5459   unsigned long long tneigh;
5460   char *keyfile;
5461
5462   sched = s;
5463   cfg = c;
5464   stats = GNUNET_STATISTICS_create (sched, "transport", cfg);
5465   validation_map = GNUNET_CONTAINER_multihashmap_create (64);
5466   /* parse configuration */
5467   if ((GNUNET_OK !=
5468        GNUNET_CONFIGURATION_get_value_number (c,
5469                                               "TRANSPORT",
5470                                               "NEIGHBOUR_LIMIT",
5471                                               &tneigh)) ||
5472       (GNUNET_OK !=
5473        GNUNET_CONFIGURATION_get_value_filename (c,
5474                                                 "GNUNETD",
5475                                                 "HOSTKEY", &keyfile)))
5476     {
5477       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5478                   _
5479                   ("Transport service is lacking key configuration settings.  Exiting.\n"));
5480       GNUNET_SCHEDULER_shutdown (s);
5481       if (stats != NULL)
5482         {
5483           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
5484           stats = NULL;
5485         }
5486       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
5487       validation_map = NULL;
5488       return;
5489     }
5490   max_connect_per_transport = (uint32_t) tneigh;
5491   peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
5492   if (peerinfo == NULL)
5493     {
5494       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5495                   _("Could not access PEERINFO service.  Exiting.\n"));
5496       GNUNET_SCHEDULER_shutdown (s);
5497       if (stats != NULL)
5498         {
5499           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
5500           stats = NULL;
5501         }
5502       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
5503       validation_map = NULL;
5504       GNUNET_free (keyfile);
5505       return;
5506     }
5507   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
5508   GNUNET_free (keyfile);
5509   if (my_private_key == NULL)
5510     {
5511       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5512                   _
5513                   ("Transport service could not access hostkey.  Exiting.\n"));
5514       GNUNET_SCHEDULER_shutdown (s);
5515       if (stats != NULL)
5516         {
5517           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
5518           stats = NULL;
5519         }
5520       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
5521       validation_map = NULL;
5522       return;
5523     }
5524   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
5525   GNUNET_CRYPTO_hash (&my_public_key,
5526                       sizeof (my_public_key), &my_identity.hashPubKey);
5527   /* setup notification */
5528   GNUNET_SERVER_disconnect_notify (server,
5529                                    &client_disconnect_notification, NULL);
5530   /* load plugins... */
5531   no_transports = 1;
5532   if (GNUNET_OK ==
5533       GNUNET_CONFIGURATION_get_value_string (c,
5534                                              "TRANSPORT", "PLUGINS", &plugs))
5535     {
5536       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5537                   _("Starting transport plugins `%s'\n"), plugs);
5538       pos = strtok (plugs, " ");
5539       while (pos != NULL)
5540         {
5541           start_transport (server, pos);
5542           no_transports = 0;
5543           pos = strtok (NULL, " ");
5544         }
5545       GNUNET_free (plugs);
5546     }
5547   GNUNET_SCHEDULER_add_delayed (sched,
5548                                 GNUNET_TIME_UNIT_FOREVER_REL,
5549                                 &shutdown_task, NULL);
5550   if (no_transports)
5551     refresh_hello ();
5552
5553 #if DEBUG_TRANSPORT
5554   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport service ready.\n"));
5555 #endif
5556   /* If we have a blacklist file, read from it */
5557   read_blacklist_file(cfg);
5558   /* process client requests */
5559   GNUNET_SERVER_add_handlers (server, handlers);
5560 }
5561
5562
5563 /**
5564  * The main function for the transport service.
5565  *
5566  * @param argc number of arguments from the command line
5567  * @param argv command line arguments
5568  * @return 0 ok, 1 on error
5569  */
5570 int
5571 main (int argc, char *const *argv)
5572 {
5573   a2s (NULL, NULL, 0); /* make compiler happy */
5574   return (GNUNET_OK ==
5575           GNUNET_SERVICE_run (argc,
5576                               argv,
5577                               "transport",
5578                               GNUNET_SERVICE_OPTION_NONE,
5579                               &run, NULL)) ? 0 : 1;
5580 }
5581
5582 /* end of gnunet-service-transport.c */