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