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 #if HAVE_LIBGLPK
  42 #include <glpk.h>
  43 #endif
  44
  45 #define DEBUG_BLACKLIST GNUNET_NO
  46
  47 #define DEBUG_PING_PONG GNUNET_NO
  48
  49 #define DEBUG_TRANSPORT_HELLO GNUNET_NO
  50
  51 #define DEBUG_ATS GNUNET_NO
  52
  53 #define VERBOSE_ATS GNUNET_NO
  54
  55 /**
  56  * Should we do some additional checks (to validate behavior
  57  * of clients)?
  58  */
  59 #define EXTRA_CHECKS GNUNET_YES
  60
  61 /**
  62  * How many messages can we have pending for a given client process
  63  * before we start to drop incoming messages?  We typically should
  64  * have only one client and so this would be the primary buffer for
  65   * messages, so the number should be chosen rather generously.
  66  *
  67  * The expectation here is that most of the time the queue is large
  68  * enough so that a drop is virtually never required.  Note that
  69  * this value must be about as large as 'TOTAL_MSGS' in the
  70  * 'test_transport_api_reliability.c', otherwise that testcase may
  71  * fail.
  72  */
  73 #define MAX_PENDING (128 * 1024)
  74
  75 /**
  76  * Size of the per-transport blacklist hash maps.
  77  */
  78 #define TRANSPORT_BLACKLIST_HT_SIZE 16
  79
  80 /**
  81  * How often should we try to reconnect to a peer using a particular
  82  * transport plugin before giving up?  Note that the plugin may be
  83  * added back to the list after PLUGIN_RETRY_FREQUENCY expires.
  84  */
  85 #define MAX_CONNECT_RETRY 3
  86
  87 /**
  88  * Limit on the number of ready-to-run tasks when validating
  89  * HELLOs.  If more tasks are ready to run, we will drop
  90  * HELLOs instead of validating them.
  91  */
  92 #define MAX_HELLO_LOAD 4
  93
  94 /**
  95  * How often must a peer violate bandwidth quotas before we start
  96  * to simply drop its messages?
  97  */
  98 #define QUOTA_VIOLATION_DROP_THRESHOLD 10
  99
 100 /**
 101  * How long until a HELLO verification attempt should time out?
 102  * Must be rather small, otherwise a partially successful HELLO
 103  * validation (some addresses working) might not be available
 104  * before a client's request for a connection fails for good.
 105  * Besides, if a single request to an address takes a long time,
 106  * then the peer is unlikely worthwhile anyway.
 107  */
 108 #define HELLO_VERIFICATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
 109
 110 /**
 111  * How long is a PONG signature valid?  We'll recycle a signature until
 112  * 1/4 of this time is remaining.  PONGs should expire so that if our
 113  * external addresses change an adversary cannot replay them indefinitely.
 114  * OTOH, we don't want to spend too much time generating PONG signatures,
 115  * so they must have some lifetime to reduce our CPU usage.
 116  */
 117 #define PONG_SIGNATURE_LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
 118
 119 /**
 120  * Priority to use for PONG messages.
 121  */
 122 #define TRANSPORT_PONG_PRIORITY 4
 123
 124 /**
 125  * How often do we re-add (cheaper) plugins to our list of plugins
 126  * to try for a given connected peer?
 127  */
 128 #define PLUGIN_RETRY_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 129
 130 /**
 131  * After how long do we expire an address in a HELLO that we just
 132  * validated?  This value is also used for our own addresses when we
 133  * create a HELLO.
 134  */
 135 #define HELLO_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 12)
 136
 137
 138 /**
 139  * How long before an existing address expires should we again try to
 140  * validate it?  Must be (significantly) smaller than
 141  * HELLO_ADDRESS_EXPIRATION.
 142  */
 143 #define HELLO_REVALIDATION_START_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
 144
 145 /**
 146  * Maximum frequency for re-evaluating latencies for all transport addresses.
 147  */
 148 #define LATENCY_EVALUATION_MAX_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)
 149
 150 /**
 151  * Maximum frequency for re-evaluating latencies for connected addresses.
 152  */
 153 #define CONNECTED_LATENCY_EVALUATION_MAX_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
 154
 155 #define VERY_BIG_DOUBLE_VALUE 100000000000LL
 156
 157 #define ATS_NEW 0
 158 #define ATS_Q_UPDATED 1
 159 #define ATS_C_UPDATED 2
 160 #define ATS_QC_UPDATED 3
 161 #define ATS_UNMODIFIED 4
 162
 163 /**
 164  * List of addresses of other peers
 165  */
 166 struct ForeignAddressList
 167 {
 168   /**
 169    * This is a linked list.
 170    */
 171   struct ForeignAddressList *next;
 172
 173   /**
 174    * Which ready list does this entry belong to.
 175    */
 176   struct ReadyList *ready_list;
 177
 178   /**
 179    * How long until we auto-expire this address (unless it is
 180    * re-confirmed by the transport)?
 181    */
 182   struct GNUNET_TIME_Absolute expires;
 183
 184   /**
 185    * Task used to re-validate addresses, updates latencies and
 186    * verifies liveness.
 187    */
 188   GNUNET_SCHEDULER_TaskIdentifier revalidate_task;
 189
 190   /**
 191    * The address.
 192    */
 193   const void *addr;
 194
 195   /**
 196    * Session (or NULL if no valid session currently exists or if the
 197    * plugin does not use sessions).
 198    */
 199   struct Session *session;
 200
 201   struct ATS_ressource_entry * ressources;
 202
 203   struct ATS_quality_entry * quality;
 204
 205   /**
 206    * What was the last latency observed for this address, plugin and peer?
 207    */
 208   struct GNUNET_TIME_Relative latency;
 209
 210   /**
 211    * If we did not successfully transmit a message to the given peer
 212    * via this connection during the specified time, we should consider
 213    * the connection to be dead.  This is used in the case that a TCP
 214    * transport simply stalls writing to the stream but does not
 215    * formerly get a signal that the other peer died.
 216    */
 217   struct GNUNET_TIME_Absolute timeout;
 218
 219   /**
 220    * How often have we tried to connect using this plugin?  Used to
 221    * discriminate against addresses that do not work well.
 222    * FIXME: not yet used, but should be!
 223    */
 224   unsigned int connect_attempts;
 225
 226   /**
 227    * DV distance to this peer (1 if no DV is used).
 228    * FIXME: need to set this from transport plugins!
 229    */
 230   uint32_t distance;
 231
 232   /**
 233    * Length of addr.
 234    */
 235   uint16_t addrlen;
 236
 237   /**
 238    * Have we ever estimated the latency of this address?  Used to
 239    * ensure that the first time we add an address, we immediately
 240    * probe its latency.
 241    */
 242   int8_t estimated;
 243
 244   /**
 245    * Are we currently connected via this address?  The first time we
 246    * successfully transmit or receive data to a peer via a particular
 247    * address, we set this to GNUNET_YES.  If we later get an error
 248    * (disconnect notification, transmission failure, timeout), we set
 249    * it back to GNUNET_NO.
 250    */
 251   int8_t connected;
 252
 253   /**
 254    * Is this plugin currently busy transmitting to the specific target?
 255    * GNUNET_NO if not (initial, default state is GNUNET_NO).   Internal
 256    * messages do not count as 'in transmit'.
 257    */
 258   int8_t in_transmit;
 259
 260   /**
 261    * Has this address been validated yet?
 262    */
 263   int8_t validated;
 264
 265 };
 266
 267
 268 /**
 269  * Entry in linked list of network addresses for ourselves.  Also
 270  * includes a cached signature for 'struct TransportPongMessage's.
 271  */
 272 struct OwnAddressList
 273 {
 274   /**
 275    * This is a linked list.
 276    */
 277   struct OwnAddressList *next;
 278
 279   /**
 280    * How long until we actually auto-expire this address (unless it is
 281    * re-confirmed by the transport)?
 282    */
 283   struct GNUNET_TIME_Absolute expires;
 284
 285   /**
 286    * How long until the current signature expires? (ZERO if the
 287    * signature was never created).
 288    */
 289   struct GNUNET_TIME_Absolute pong_sig_expires;
 290
 291   /**
 292    * Signature for a 'struct TransportPongMessage' for this address.
 293    */
 294   struct GNUNET_CRYPTO_RsaSignature pong_signature;
 295
 296   /**
 297    * Length of addr.
 298    */
 299   uint32_t addrlen;
 300
 301 };
 302
 303
 304 /**
 305  * Entry in linked list of all of our plugins.
 306  */
 307 struct TransportPlugin
 308 {
 309
 310   /**
 311    * This is a linked list.
 312    */
 313   struct TransportPlugin *next;
 314
 315   /**
 316    * API of the transport as returned by the plugin's
 317    * initialization function.
 318    */
 319   struct GNUNET_TRANSPORT_PluginFunctions *api;
 320
 321   /**
 322    * Short name for the plugin (i.e. "tcp").
 323    */
 324   char *short_name;
 325
 326   /**
 327    * Name of the library (i.e. "gnunet_plugin_transport_tcp").
 328    */
 329   char *lib_name;
 330
 331   /**
 332    * List of our known addresses for this transport.
 333    */
 334   struct OwnAddressList *addresses;
 335
 336   /**
 337    * Environment this transport service is using
 338    * for this plugin.
 339    */
 340   struct GNUNET_TRANSPORT_PluginEnvironment env;
 341
 342   /**
 343    * ID of task that is used to clean up expired addresses.
 344    */
 345   GNUNET_SCHEDULER_TaskIdentifier address_update_task;
 346
 347   /**
 348    * Set to GNUNET_YES if we need to scrap the existing list of
 349    * "addresses" and start fresh when we receive the next address
 350    * update from a transport.  Set to GNUNET_NO if we should just add
 351    * the new address to the list and wait for the commit call.
 352    */
 353   int rebuild;
 354
 355   struct ATS_plugin * rc;
 356
 357   /**
 358    * Hashmap of blacklisted peers for this particular transport.
 359    */
 360   struct GNUNET_CONTAINER_MultiHashMap *blacklist;
 361 };
 362
 363 struct NeighbourList;
 364
 365 /**
 366  * For each neighbour we keep a list of messages
 367  * that we still want to transmit to the neighbour.
 368  */
 369 struct MessageQueue
 370 {
 371
 372   /**
 373    * This is a doubly linked list.
 374    */
 375   struct MessageQueue *next;
 376
 377   /**
 378    * This is a doubly linked list.
 379    */
 380   struct MessageQueue *prev;
 381
 382   /**
 383    * The message(s) we want to transmit, GNUNET_MessageHeader(s)
 384    * stuck together in memory.  Allocated at the end of this struct.
 385    */
 386   const char *message_buf;
 387
 388   /**
 389    * Size of the message buf
 390    */
 391   size_t message_buf_size;
 392
 393   /**
 394    * Client responsible for queueing the message;
 395    * used to check that a client has no two messages
 396    * pending for the same target.  Can be NULL.
 397    */
 398   struct TransportClient *client;
 399
 400   /**
 401    * Using which specific address should we send this message?
 402    */
 403   struct ForeignAddressList *specific_address;
 404
 405   /**
 406    * Peer ID of the Neighbour this entry belongs to.
 407    */
 408   struct GNUNET_PeerIdentity neighbour_id;
 409
 410   /**
 411    * Plugin that we used for the transmission.
 412    * NULL until we scheduled a transmission.
 413    */
 414   struct TransportPlugin *plugin;
 415
 416   /**
 417    * At what time should we fail?
 418    */
 419   struct GNUNET_TIME_Absolute timeout;
 420
 421   /**
 422    * Internal message of the transport system that should not be
 423    * included in the usual SEND-SEND_OK transmission confirmation
 424    * traffic management scheme.  Typically, "internal_msg" will
 425    * be set whenever "client" is NULL (but it is not strictly
 426    * required).
 427    */
 428   int internal_msg;
 429
 430   /**
 431    * How important is the message?
 432    */
 433   unsigned int priority;
 434
 435 };
 436
 437
 438 /**
 439  * For a given Neighbour, which plugins are available
 440  * to talk to this peer and what are their costs?
 441  */
 442 struct ReadyList
 443 {
 444   /**
 445    * This is a linked list.
 446    */
 447   struct ReadyList *next;
 448
 449   /**
 450    * Which of our transport plugins does this entry
 451    * represent?
 452    */
 453   struct TransportPlugin *plugin;
 454
 455   /**
 456    * Transport addresses, latency, and readiness for
 457    * this particular plugin.
 458    */
 459   struct ForeignAddressList *addresses;
 460
 461   /**
 462    * To which neighbour does this ready list belong to?
 463    */
 464   struct NeighbourList *neighbour;
 465 };
 466
 467
 468 /**
 469  * Entry in linked list of all of our current neighbours.
 470  */
 471 struct NeighbourList
 472 {
 473
 474   /**
 475    * This is a linked list.
 476    */
 477   struct NeighbourList *next;
 478
 479   /**
 480    * Which of our transports is connected to this peer
 481    * and what is their status?
 482    */
 483   struct ReadyList *plugins;
 484
 485   /**
 486    * Head of list of messages we would like to send to this peer;
 487    * must contain at most one message per client.
 488    */
 489   struct MessageQueue *messages_head;
 490
 491   /**
 492    * Tail of list of messages we would like to send to this peer; must
 493    * contain at most one message per client.
 494    */
 495   struct MessageQueue *messages_tail;
 496
 497   /**
 498    * Buffer for at most one payload message used when we receive
 499    * payload data before our PING-PONG has succeeded.  We then
 500    * store such messages in this intermediary buffer until the
 501    * connection is fully up.
 502    */
 503   struct GNUNET_MessageHeader *pre_connect_message_buffer;
 504
 505   /**
 506    * Context for peerinfo iteration.
 507    * NULL after we are done processing peerinfo's information.
 508    */
 509   struct GNUNET_PEERINFO_IteratorContext *piter;
 510
 511   /**
 512    * Public key for this peer.   Valid only if the respective flag is set below.
 513    */
 514   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
 515
 516   /**
 517    * Identity of this neighbour.
 518    */
 519   struct GNUNET_PeerIdentity id;
 520
 521   /**
 522    * ID of task scheduled to run when this peer is about to
 523    * time out (will free resources associated with the peer).
 524    */
 525   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 526
 527   /**
 528    * ID of task scheduled to run when we should retry transmitting
 529    * the head of the message queue.  Actually triggered when the
 530    * transmission is timing out (we trigger instantly when we have
 531    * a chance of success).
 532    */
 533   GNUNET_SCHEDULER_TaskIdentifier retry_task;
 534
 535   /**
 536    * How long until we should consider this peer dead
 537    * (if we don't receive another message in the
 538    * meantime)?
 539    */
 540   struct GNUNET_TIME_Absolute peer_timeout;
 541
 542   /**
 543    * Tracker for inbound bandwidth.
 544    */
 545   struct GNUNET_BANDWIDTH_Tracker in_tracker;
 546
 547   /**
 548    * The latency we have seen for this particular address for
 549    * this particular peer.  This latency may have been calculated
 550    * over multiple transports.  This value reflects how long it took
 551    * us to receive a response when SENDING via this particular
 552    * transport/neighbour/address combination!
 553    *
 554    * FIXME: we need to periodically send PINGs to update this
 555    * latency (at least more often than the current "huge" (11h?)
 556    * update interval).
 557    */
 558   struct GNUNET_TIME_Relative latency;
 559
 560   /**
 561    * How often has the other peer (recently) violated the
 562    * inbound traffic limit?  Incremented by 10 per violation,
 563    * decremented by 1 per non-violation (for each
 564    * time interval).
 565    */
 566   unsigned int quota_violation_count;
 567
 568   /**
 569    * DV distance to this peer (1 if no DV is used).
 570    */
 571   uint32_t distance;
 572
 573   /**
 574    * Have we seen an PONG from this neighbour in the past (and
 575    * not had a disconnect since)?
 576    */
 577   int received_pong;
 578
 579   /**
 580    * Do we have a valid public key for this neighbour?
 581    */
 582   int public_key_valid;
 583
 584   /**
 585    * Performance data for the peer.
 586    */
 587   struct GNUNET_TRANSPORT_ATS_Information *ats;
 588
 589   /**
 590    * Identity of the neighbour.
 591    */
 592   struct GNUNET_PeerIdentity peer;
 593
 594 };
 595
 596 /**
 597  * Message used to ask a peer to validate receipt (to check an address
 598  * from a HELLO).  Followed by the address we are trying to validate,
 599  * or an empty address if we are just sending a PING to confirm that a
 600  * connection which the receiver (of the PING) initiated is still valid.
 601  */
 602 struct TransportPingMessage
 603 {
 604
 605   /**
 606    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PING
 607    */
 608   struct GNUNET_MessageHeader header;
 609
 610   /**
 611    * Challenge code (to ensure fresh reply).
 612    */
 613   uint32_t challenge GNUNET_PACKED;
 614
 615   /**
 616    * Who is the intended recipient?
 617    */
 618   struct GNUNET_PeerIdentity target;
 619
 620 };
 621
 622
 623 /**
 624  * Message used to validate a HELLO.  The challenge is included in the
 625  * confirmation to make matching of replies to requests possible.  The
 626  * signature signs our public key, an expiration time and our address.<p>
 627  *
 628  * This message is followed by our transport address that the PING tried
 629  * to confirm (if we liked it).  The address can be empty (zero bytes)
 630  * if the PING had not address either (and we received the request via
 631  * a connection that we initiated).
 632  */
 633 struct TransportPongMessage
 634 {
 635
 636   /**
 637    * Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_PONG
 638    */
 639   struct GNUNET_MessageHeader header;
 640
 641   /**
 642    * Challenge code from PING (showing freshness).  Not part of what
 643    * is signed so that we can re-use signatures.
 644    */
 645   uint32_t challenge GNUNET_PACKED;
 646
 647   /**
 648    * Signature.
 649    */
 650   struct GNUNET_CRYPTO_RsaSignature signature;
 651
 652   /**
 653    * What are we signing and why?  Two possible reason codes can be here:
 654    * GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN to confirm that this is a
 655    * plausible address for this peer (pid is set to identity of signer); or
 656    * GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING to confirm that this is
 657    * an address we used to connect to the peer with the given pid.
 658    */
 659   struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
 660
 661   /**
 662    * When does this signature expire?
 663    */
 664   struct GNUNET_TIME_AbsoluteNBO expiration;
 665
 666   /**
 667    * Either the identity of the peer Who signed this message, or the
 668    * identity of the peer that we're connected to using the given
 669    * address (depending on purpose.type).
 670    */
 671   struct GNUNET_PeerIdentity pid;
 672
 673   /**
 674    * Size of address appended to this message (part of what is
 675    * being signed, hence not redundant).
 676    */
 677   uint32_t addrlen;
 678
 679 };
 680
 681
 682 /**
 683  * Linked list of messages to be transmitted to the client.  Each
 684  * entry is followed by the actual message.
 685  */
 686 struct ClientMessageQueueEntry
 687 {
 688   /**
 689    * This is a doubly-linked list.
 690    */
 691   struct ClientMessageQueueEntry *next;
 692
 693   /**
 694    * This is a doubly-linked list.
 695    */
 696   struct ClientMessageQueueEntry *prev;
 697 };
 698
 699
 700 /**
 701  * Client connected to the transport service.
 702  */
 703 struct TransportClient
 704 {
 705
 706   /**
 707    * This is a linked list.
 708    */
 709   struct TransportClient *next;
 710
 711   /**
 712    * Handle to the client.
 713    */
 714   struct GNUNET_SERVER_Client *client;
 715
 716   /**
 717    * Linked list of messages yet to be transmitted to
 718    * the client.
 719    */
 720   struct ClientMessageQueueEntry *message_queue_head;
 721
 722   /**
 723    * Tail of linked list of messages yet to be transmitted to the
 724    * client.
 725    */
 726   struct ClientMessageQueueEntry *message_queue_tail;
 727
 728   /**
 729    * Current transmit request handle.
 730    */
 731   struct GNUNET_CONNECTION_TransmitHandle *th;
 732
 733   /**
 734    * Is a call to "transmit_send_continuation" pending?  If so, we
 735    * must not free this struct (even if the corresponding client
 736    * disconnects) and instead only remove it from the linked list and
 737    * set the "client" field to NULL.
 738    */
 739   int tcs_pending;
 740
 741   /**
 742    * Length of the list of messages pending for this client.
 743    */
 744   unsigned int message_count;
 745
 746 };
 747
 748
 749 /**
 750  * Context of currently active requests to peerinfo
 751  * for validation of HELLOs.
 752  */
 753 struct CheckHelloValidatedContext;
 754
 755
 756 /**
 757  * Entry in map of all HELLOs awaiting validation.
 758  */
 759 struct ValidationEntry
 760 {
 761
 762   /**
 763    * NULL if this entry is not part of a larger HELLO validation.
 764    */
 765   struct CheckHelloValidatedContext *chvc;
 766
 767   /**
 768    * The address, actually a pointer to the end
 769    * of this struct.  Do not free!
 770    */
 771   const void *addr;
 772
 773   /**
 774    * Name of the transport.
 775    */
 776   char *transport_name;
 777
 778   /**
 779    * The public key of the peer.
 780    */
 781   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
 782
 783   /**
 784    * ID of task that will clean up this entry if we don't succeed
 785    * with the validation first.
 786    */
 787   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 788
 789   /**
 790    * At what time did we send this validation?
 791    */
 792   struct GNUNET_TIME_Absolute send_time;
 793
 794   /**
 795    * Session being validated (or NULL for none).
 796    */
 797   struct Session *session;
 798
 799   /**
 800    * Challenge number we used.
 801    */
 802   uint32_t challenge;
 803
 804   /**
 805    * Length of addr.
 806    */
 807   uint16_t addrlen;
 808
 809 };
 810
 811
 812 /**
 813  * Context of currently active requests to peerinfo
 814  * for validation of HELLOs.
 815  */
 816 struct CheckHelloValidatedContext
 817 {
 818
 819   /**
 820    * This is a doubly-linked list.
 821    */
 822   struct CheckHelloValidatedContext *next;
 823
 824   /**
 825    * This is a doubly-linked list.
 826    */
 827   struct CheckHelloValidatedContext *prev;
 828
 829   /**
 830    * Hello that we are validating.
 831    */
 832   const struct GNUNET_HELLO_Message *hello;
 833
 834   /**
 835    * Context for peerinfo iteration.
 836    * NULL after we are done processing peerinfo's information.
 837    */
 838   struct GNUNET_PEERINFO_IteratorContext *piter;
 839
 840   /**
 841    * Was a HELLO known for this peer to peerinfo?
 842    */
 843   int hello_known;
 844
 845   /**
 846    * Number of validation entries currently referring to this
 847    * CHVC.
 848    */
 849   unsigned int ve_count;
 850 };
 851
 852 struct ATS_quality_metric
 853 {
 854         int index;
 855         int atis_index;
 856         char * name;
 857 };
 858
 859 struct ATS_mechanism
 860 {
 861         struct ATS_mechanism * prev;
 862         struct ATS_mechanism * next;
 863         struct ForeignAddressList * addr;
 864         struct TransportPlugin * plugin;
 865         struct ATS_peer * peer;
 866         int col_index;
 867         int     id;
 868         struct ATS_ressource_cost * rc;
 869 };
 870
 871 struct ATS_peer
 872 {
 873         int id;
 874         struct GNUNET_PeerIdentity peer;
 875         struct NeighbourList * n;
 876         struct ATS_mechanism * m_head;
 877         struct ATS_mechanism * m_tail;
 878
 879         /* preference value f */
 880         double f;
 881         int     t;
 882 };
 883
 884 struct ATS_stat
 885 {
 886         /**
 887          * result of last GLPK run
 888          * 5 == OPTIMAL
 889          */
 890         int solution;
 891
 892         /**
 893          * Ressource costs or quality metrics changed
 894          * update problem before solving
 895          */
 896         int modified_resources;
 897
 898         /**
 899          * Ressource costs or quality metrics changed, update matrix
 900          * update problem before solving
 901          */
 902         int modified_quality;
 903
 904         /**
 905          * Peers have connected or disconnected
 906          * problem has to be recreated
 907          */
 908         int recreate_problem;
 909
 910         /**
 911          * Was the available basis invalid and we needed to rerun simplex?
 912          */
 913         int simplex_rerun_required;
 914
 915         /**
 916          * is problem currently valid and can it be solved
 917          */
 918         int valid;
 919
 920         /**
 921          * Number of transport mechanisms in the problem
 922          */
 923         int c_mechs;
 924
 925         /**
 926          * Number of transport mechanisms in the problem
 927          */
 928         int c_peers;
 929
 930         /**
 931          * row index where quality related rows start
 932          */
 933         int begin_qm;
 934
 935         /**
 936          * row index where quality related rows end
 937          */
 938         int end_qm;
 939
 940         /**
 941          * row index where ressource cost related rows start
 942          */
 943         int begin_cr;
 944
 945         /**
 946          * row index where ressource cost related rows end
 947          */
 948         int end_cr;
 949
 950         /**
 951          * column index for objective function value d
 952          */
 953         int col_d;
 954
 955         /**
 956          * column index for objective function value u
 957          */
 958         int col_u;
 959
 960         /**
 961          * column index for objective function value r
 962          */
 963         int col_r;
 964
 965         /**
 966          * column index for objective function value quality metrics
 967          */
 968         int col_qm;
 969
 970         /**
 971          * column index for objective function value cost ressources
 972          */
 973         int col_cr;
 974 };
 975
 976 struct ATS_ressource_entry
 977 {
 978         /* index in ressources array */
 979         int index;
 980         /* depending ATSi parameter to calculcate limits */
 981         int atis_index;
 982         /* lower bound */
 983         double c;
 984 };
 985
 986
 987 struct ATS_ressource
 988 {
 989         /* index in ressources array */
 990         int index;
 991         /* depending ATSi parameter to calculcate limits */
 992         int atis_index;
 993         /* cfg option to load limits */
 994         char * cfg_param;
 995         /* lower bound */
 996         double c_min;
 997         /* upper bound */
 998         double c_max;
 999
1000         /* cofficients for the specific plugins */
1001         double c_unix;
1002         double c_tcp;
1003         double c_udp;
1004         double c_http;
1005         double c_https;
1006         double c_wlan;
1007         double c_default;
1008 };
1009
1010 static struct ATS_ressource ressources[] =
1011 {
1012                 /* FIXME: the coefficients for the specific plugins */
1013                 {1, 7, "LAN_BW_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 1, 1, 2, 2, 1, 3},
1014                 {2, 7, "WAN_BW_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 1, 1, 2, 2, 2, 3},
1015                 {3, 4, "WLAN_ENERGY_LIMIT", 0, VERY_BIG_DOUBLE_VALUE, 0, 0, 0, 0, 0, 2, 1}
1016 /*
1017                 {4, 4, "COST_ENERGY_CONSUMPTION", VERY_BIG_DOUBLE_VALUE},
1018                 {5, 5, "COST_CONNECT", VERY_BIG_DOUBLE_VALUE},
1019                 {6, 6, "COST_BANDWITH_AVAILABLE", VERY_BIG_DOUBLE_VALUE},
1020                 {7, 7, "COST_NETWORK_OVERHEAD", VERY_BIG_DOUBLE_VALUE},*/
1021 };
1022
1023 static int available_ressources = 3;
1024
1025
1026
1027 struct ATS_info
1028 {
1029
1030         /**
1031          * Time of last execution
1032          */
1033         struct GNUNET_TIME_Absolute last;
1034         /**
1035          * Minimum intervall between two executions
1036          */
1037         struct GNUNET_TIME_Relative min_delta;
1038         /**
1039          * Regular intervall when execution is triggered
1040          */
1041         struct GNUNET_TIME_Relative exec_interval;
1042         /**
1043          * Maximum execution time per calculation
1044          */
1045         struct GNUNET_TIME_Relative max_exec_duration;
1046
1047 #if HAVE_LIBGLPK
1048         /**
1049          * GLPK (MLP) problem object
1050          */
1051         glp_prob *prob;
1052 #endif
1053
1054         /**
1055          * task to recalculate the bandwidth assignment
1056          */
1057         GNUNET_SCHEDULER_TaskIdentifier ats_task;
1058
1059         /**
1060          * Current state of the GLPK problem
1061          */
1062         struct ATS_stat stat;
1063
1064         /**
1065          * mechanisms used in current problem
1066          * needed for problem modification
1067          */
1068         struct ATS_mechanism * mechanisms;
1069
1070         /**
1071          * peers used in current problem
1072          * needed for problem modification
1073          */
1074         struct ATS_peer * peers;
1075
1076         /**
1077          * number of successful executions
1078          */
1079         int successful_executions;
1080
1081         /**
1082          * number with an invalid result
1083          */
1084         int invalid_executions;
1085
1086         /**
1087          * Maximum number of LP iterations per calculation
1088          */
1089         int max_iterations;
1090
1091         /**
1092          * Dump problem to a file?
1093          */
1094         int save_mlp;
1095
1096         /**
1097          * Dump solution to a file
1098          */
1099         int save_solution;
1100
1101         /**
1102          * Dump solution when minimum peers:
1103          */
1104         int dump_min_peers;
1105
1106         /**
1107          * Dump solution when minimum addresses:
1108          */
1109         int dump_min_addr;
1110
1111         /**
1112          * Dump solution overwrite file:
1113          */
1114         int dump_overwrite;
1115
1116         /**
1117          * Diversity weight
1118          */
1119         double D;
1120
1121         /**
1122          * Utility weight
1123          */
1124         double U;
1125
1126         /**
1127          * Relativity weight
1128          */
1129         double R;
1130
1131         /**
1132          * Minimum bandwidth per peer
1133          */
1134         int v_b_min;
1135
1136         /**
1137          * Minimum number of connections per peer
1138          */
1139         int v_n_min;
1140 };
1141
1142
1143 /**
1144  * Our HELLO message.
1145  */
1146 static struct GNUNET_HELLO_Message *our_hello;
1147
1148 /**
1149  * Our public key.
1150  */
1151 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
1152
1153 /**
1154  * Our identity.
1155  */
1156 static struct GNUNET_PeerIdentity my_identity;
1157
1158 /**
1159  * Our private key.
1160  */
1161 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
1162
1163 /**
1164  * Our configuration.
1165  */
1166 const struct GNUNET_CONFIGURATION_Handle *cfg;
1167
1168 /**
1169  * Linked list of all clients to this service.
1170  */
1171 static struct TransportClient *clients;
1172
1173 /**
1174  * All loaded plugins.
1175  */
1176 static struct TransportPlugin *plugins;
1177
1178 /**
1179  * Handle to peerinfo service.
1180  */
1181 static struct GNUNET_PEERINFO_Handle *peerinfo;
1182
1183 /**
1184  * All known neighbours and their HELLOs.
1185  */
1186 static struct NeighbourList *neighbours;
1187
1188 /**
1189  * Number of neighbours we'd like to have.
1190  */
1191 static uint32_t max_connect_per_transport;
1192
1193 /**
1194  * Head of linked list.
1195  */
1196 static struct CheckHelloValidatedContext *chvc_head;
1197
1198 /**
1199  * Tail of linked list.
1200  */
1201 static struct CheckHelloValidatedContext *chvc_tail;
1202
1203 /**
1204  * Map of PeerIdentities to 'struct ValidationEntry*'s (addresses
1205  * of the given peer that we are currently validating).
1206  */
1207 static struct GNUNET_CONTAINER_MultiHashMap *validation_map;
1208
1209 /**
1210  * Handle for reporting statistics.
1211  */
1212 static struct GNUNET_STATISTICS_Handle *stats;
1213
1214 /**
1215  * Handle for ats information
1216  */
1217 static struct ATS_info *ats;
1218
1219 struct ATS_quality_entry
1220 {
1221         int index;
1222         int atsi_index;
1223         uint32_t values[3];
1224         int current;
1225 };
1226
1227 static struct ATS_quality_metric qm[] =
1228 {
1229                 {1, 1028, "QUALITY_NET_DISTANCE"},
1230                 {2, 1034, "QUALITY_NET_DELAY"},
1231 };
1232 static int available_quality_metrics = 2;
1233
1234
1235 /**
1236  * The peer specified by the given neighbour has timed-out or a plugin
1237  * has disconnected.  We may either need to do nothing (other plugins
1238  * still up), or trigger a full disconnect and clean up.  This
1239  * function updates our state and do the necessary notifications.
1240  * Also notifies our clients that the neighbour is now officially
1241  * gone.
1242  *
1243  * @param n the neighbour list entry for the peer
1244  * @param check should we just check if all plugins
1245  *        disconnected or must we ask all plugins to
1246  *        disconnect?
1247  */
1248 static void disconnect_neighbour (struct NeighbourList *n, int check);
1249
1250 /**
1251  * Check the ready list for the given neighbour and if a plugin is
1252  * ready for transmission (and if we have a message), do so!
1253  *
1254  * @param nexi target peer for which to transmit
1255  */
1256 static void try_transmission_to_peer (struct NeighbourList *n);
1257
1258 static void ats_shutdown ( );
1259
1260 static void ats_notify_peer_connect (
1261                 const struct GNUNET_PeerIdentity *peer,
1262                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data, int ats_count);
1263
1264 static void ats_notify_peer_disconnect (
1265                 const struct GNUNET_PeerIdentity *peer);
1266
1267 #if 0
1268 static void ats_notify_ats_data (
1269                 const struct GNUNET_PeerIdentity *peer,
1270                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data);
1271 #endif
1272
1273 struct ForeignAddressList * ats_get_preferred_address (
1274                 struct NeighbourList *n);
1275
1276 static void
1277 ats_calculate_bandwidth_distribution ();
1278
1279 /**
1280  * Find an entry in the neighbour list for a particular peer.
1281  *
1282  * @return NULL if not found.
1283  */
1284 static struct NeighbourList *
1285 find_neighbour (const struct GNUNET_PeerIdentity *key)
1286 {
1287   struct NeighbourList *head = neighbours;
1288
1289   while ((head != NULL) &&
1290         (0 != memcmp (key, &head->id, sizeof (struct GNUNET_PeerIdentity))))
1291     head = head->next;
1292   return head;
1293 }
1294
1295 static int update_addr_value (struct ForeignAddressList *fal, uint32_t value , int ats_index)
1296 {
1297         int c;
1298         int set = GNUNET_NO;
1299         for (c=0; c<available_quality_metrics; c++)
1300         {
1301           if (ats_index == qm[c].atis_index)
1302           {
1303                   fal->quality[c].values[0] = fal->quality[c].values[1];
1304                   fal->quality[c].values[1] = fal->quality[c].values[2];
1305                   fal->quality[c].values[2] = value;
1306                   set = GNUNET_YES;
1307                   ats->stat.modified_quality = GNUNET_YES;
1308           }
1309         }
1310         if (set == GNUNET_NO)
1311         {
1312           for (c=0; c<available_ressources; c++)
1313           {
1314                   if (ats_index == ressources[c].atis_index)
1315                   {
1316                           fal->ressources[c].c = value;
1317                           set = GNUNET_YES;
1318                           ats->stat.modified_resources = GNUNET_YES;
1319                   }
1320           }
1321         }
1322
1323         return set;
1324 }
1325
1326 static int
1327 update_addr_ats (struct ForeignAddressList *fal,
1328                  const struct GNUNET_TRANSPORT_ATS_Information *ats_data,
1329                  int ats_count)
1330 {
1331   int c1, set;
1332   set = GNUNET_NO;
1333   for (c1=0; c1<ats_count; c1++)
1334     {
1335       set = update_addr_value(fal, ntohl(ats_data[c1].value), ntohl(ats_data[c1].type));
1336     }
1337   return set;
1338 }
1339
1340 /**
1341  * Find an entry in the transport list for a particular transport.
1342  *
1343  * @return NULL if not found.
1344  */
1345 static struct TransportPlugin *
1346 find_transport (const char *short_name)
1347 {
1348   struct TransportPlugin *head = plugins;
1349   while ((head != NULL) && (0 != strcmp (short_name, head->short_name)))
1350     head = head->next;
1351   return head;
1352 }
1353
1354 /**
1355  * Is a particular peer blacklisted for a particular transport?
1356  *
1357  * @param peer the peer to check for
1358  * @param plugin the plugin used to connect to the peer
1359  *
1360  * @return GNUNET_YES if the peer is blacklisted, GNUNET_NO if not
1361  */
1362 static int
1363 is_blacklisted (const struct GNUNET_PeerIdentity *peer, struct TransportPlugin *plugin)
1364 {
1365
1366   if (plugin->blacklist != NULL)
1367     {
1368       if (GNUNET_CONTAINER_multihashmap_contains (plugin->blacklist, &peer->hashPubKey) == GNUNET_YES)
1369         {
1370 #if DEBUG_BLACKLIST
1371           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1372                       "Peer `%s:%s' is blacklisted!\n",
1373                       plugin->short_name, GNUNET_i2s (peer));
1374 #endif
1375           if (stats != NULL)
1376             GNUNET_STATISTICS_update (stats, "# blacklisted peers refused", 1, GNUNET_NO);
1377           return GNUNET_YES;
1378         }
1379     }
1380
1381   return GNUNET_NO;
1382 }
1383
1384
1385 static void
1386 add_peer_to_blacklist (struct GNUNET_PeerIdentity *peer,
1387                        char *transport_name)
1388 {
1389   struct TransportPlugin *plugin;
1390
1391   plugin = find_transport(transport_name);
1392   if (plugin == NULL) /* Nothing to do */
1393     return;
1394 #if DEBUG_TRANSPORT
1395   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1396               "Adding peer `%s' with plugin `%s' to blacklist\n",
1397               GNUNET_i2s (peer),
1398               transport_name);
1399 #endif
1400   if (plugin->blacklist == NULL)
1401     plugin->blacklist = GNUNET_CONTAINER_multihashmap_create(TRANSPORT_BLACKLIST_HT_SIZE);
1402   GNUNET_assert(plugin->blacklist != NULL);
1403   GNUNET_CONTAINER_multihashmap_put(plugin->blacklist, &peer->hashPubKey,
1404                                     NULL,
1405                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
1406 }
1407
1408
1409 /**
1410  * Read the blacklist file, containing transport:peer entries.
1411  * Provided the transport is loaded, set up hashmap with these
1412  * entries to blacklist peers by transport.
1413  *
1414  */
1415 static void
1416 read_blacklist_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
1417 {
1418   char *fn;
1419   char *data;
1420   size_t pos;
1421   size_t colon_pos;
1422   int tsize;
1423   struct GNUNET_PeerIdentity pid;
1424   struct stat frstat;
1425   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
1426   unsigned int entries_found;
1427   char *transport_name;
1428
1429   if (GNUNET_OK !=
1430       GNUNET_CONFIGURATION_get_value_filename (cfg,
1431                                                "TRANSPORT",
1432                                                "BLACKLIST_FILE",
1433                                                &fn))
1434     {
1435 #if DEBUG_TRANSPORT
1436       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1437                   "Option `%s' in section `%s' not specified!\n",
1438                   "BLACKLIST_FILE",
1439                   "TRANSPORT");
1440 #endif
1441       return;
1442     }
1443   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
1444     GNUNET_DISK_fn_write (fn, NULL, 0, GNUNET_DISK_PERM_USER_READ
1445         | GNUNET_DISK_PERM_USER_WRITE);
1446   if (0 != STAT (fn, &frstat))
1447     {
1448       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1449                   _("Could not read blacklist file `%s'\n"), fn);
1450       GNUNET_free (fn);
1451       return;
1452     }
1453   if (frstat.st_size == 0)
1454     {
1455 #if DEBUG_TRANSPORT
1456       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1457                   _("Blacklist file `%s' is empty.\n"),
1458                   fn);
1459 #endif
1460       GNUNET_free (fn);
1461       return;
1462     }
1463   /* FIXME: use mmap */
1464   data = GNUNET_malloc_large (frstat.st_size);
1465   GNUNET_assert(data != NULL);
1466   if (frstat.st_size !=
1467       GNUNET_DISK_fn_read (fn, data, frstat.st_size))
1468     {
1469       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1470                   _("Failed to read blacklist from `%s'\n"), fn);
1471       GNUNET_free (fn);
1472       GNUNET_free (data);
1473       return;
1474     }
1475   entries_found = 0;
1476   pos = 0;
1477   while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
1478     pos++;
1479   while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
1480          (pos <= frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
1481     {
1482       colon_pos = pos;
1483       while ((colon_pos < frstat.st_size) && (data[colon_pos] != ':') && !isspace ( (unsigned char) data[colon_pos]))
1484         colon_pos++;
1485
1486       if (colon_pos >= frstat.st_size)
1487         {
1488           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1489                       _("Syntax error in blacklist file at offset %llu, giving up!\n"),
1490                       (unsigned long long) colon_pos);
1491           GNUNET_free (fn);
1492           GNUNET_free (data);
1493           return;
1494         }
1495
1496       if (isspace( (unsigned char) data[colon_pos]))
1497       {
1498         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1499                     _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
1500                     (unsigned long long) colon_pos);
1501         pos = colon_pos;
1502         while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
1503           pos++;
1504         continue;
1505       }
1506       tsize = colon_pos - pos;
1507       if ((pos >= frstat.st_size) || (pos + tsize >= frstat.st_size) || (tsize == 0))
1508         {
1509           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1510                       _("Syntax error in blacklist file at offset %llu, giving up!\n"),
1511                       (unsigned long long) colon_pos);
1512           GNUNET_free (fn);
1513           GNUNET_free (data);
1514           return;
1515         }
1516
1517       if (tsize < 1)
1518         continue;
1519
1520       transport_name = GNUNET_malloc(tsize + 1);
1521       memcpy(transport_name, &data[pos], tsize);
1522       pos = colon_pos + 1;
1523 #if DEBUG_TRANSPORT
1524       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1525                   "Read transport name %s in blacklist file.\n",
1526                   transport_name);
1527 #endif
1528       memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
1529       if (!isspace ( (unsigned char) enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
1530         {
1531           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1532                       _("Syntax error in blacklist file at offset %llu, skipping bytes.\n"),
1533                       (unsigned long long) pos);
1534           pos++;
1535           while ((pos < frstat.st_size) && (!isspace ( (unsigned char) data[pos])))
1536             pos++;
1537           GNUNET_free_non_null(transport_name);
1538           continue;
1539         }
1540       enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
1541       if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
1542         {
1543           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1544                       _("Syntax error in blacklist file at offset %llu, skipping bytes `%s'.\n"),
1545                       (unsigned long long) pos,
1546                       &enc);
1547         }
1548       else
1549         {
1550           if (0 != memcmp (&pid,
1551                            &my_identity,
1552                            sizeof (struct GNUNET_PeerIdentity)))
1553             {
1554               entries_found++;
1555               add_peer_to_blacklist (&pid,
1556                                      transport_name);
1557             }
1558           else
1559             {
1560               GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1561                           _("Found myself `%s' in blacklist (useless, ignored)\n"),
1562                           GNUNET_i2s (&pid));
1563             }
1564         }
1565       pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
1566       GNUNET_free_non_null(transport_name);
1567       while ((pos < frstat.st_size) && isspace ( (unsigned char) data[pos]))
1568         pos++;
1569     }
1570   GNUNET_STATISTICS_update (stats, "# Transport entries blacklisted", entries_found, GNUNET_NO);
1571   GNUNET_free (data);
1572   GNUNET_free (fn);
1573 }
1574
1575
1576 /**
1577  * Function called to notify a client about the socket being ready to
1578  * queue more data.  "buf" will be NULL and "size" zero if the socket
1579  * was closed for writing in the meantime.
1580  *
1581  * @param cls closure
1582  * @param size number of bytes available in buf
1583  * @param buf where the callee should write the message
1584  * @return number of bytes written to buf
1585  */
1586 static size_t
1587 transmit_to_client_callback (void *cls, size_t size, void *buf)
1588 {
1589   struct TransportClient *client = cls;
1590   struct ClientMessageQueueEntry *q;
1591   uint16_t msize;
1592   size_t tsize;
1593   const struct GNUNET_MessageHeader *msg;
1594   char *cbuf;
1595
1596   client->th = NULL;
1597   if (buf == NULL)
1598     {
1599 #if DEBUG_TRANSPORT
1600       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1601                   "Transmission to client failed, closing connection.\n");
1602 #endif
1603       /* fatal error with client, free message queue! */
1604       while (NULL != (q = client->message_queue_head))
1605         {
1606           GNUNET_STATISTICS_update (stats,
1607                                     gettext_noop ("# bytes discarded (could not transmit to client)"),
1608                                     ntohs (((const struct GNUNET_MessageHeader*)&q[1])->size),
1609                                     GNUNET_NO);
1610           GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
1611                                        client->message_queue_tail,
1612                                        q);
1613           GNUNET_free (q);
1614         }
1615       client->message_count = 0;
1616       return 0;
1617     }
1618   cbuf = buf;
1619   tsize = 0;
1620   while (NULL != (q = client->message_queue_head))
1621     {
1622       msg = (const struct GNUNET_MessageHeader *) &q[1];
1623       msize = ntohs (msg->size);
1624       if (msize + tsize > size)
1625         break;
1626 #if DEBUG_TRANSPORT
1627       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1628                   "Transmitting message of type %u to client.\n",
1629                   ntohs (msg->type));
1630 #endif
1631       GNUNET_CONTAINER_DLL_remove (client->message_queue_head,
1632                                    client->message_queue_tail,
1633                                    q);
1634       memcpy (&cbuf[tsize], msg, msize);
1635       tsize += msize;
1636       GNUNET_free (q);
1637       client->message_count--;
1638     }
1639   if (NULL != q)
1640     {
1641       GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
1642       client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
1643                                                         msize,
1644                                                         GNUNET_TIME_UNIT_FOREVER_REL,
1645                                                         &transmit_to_client_callback,
1646                                                         client);
1647       GNUNET_assert (client->th != NULL);
1648     }
1649   return tsize;
1650 }
1651
1652
1653 /**
1654  * Convert an address to a string.
1655  *
1656  * @param plugin name of the plugin responsible for the address
1657  * @param addr binary address
1658  * @param addr_len number of bytes in addr
1659  * @return NULL on error, otherwise address string
1660  */
1661 static const char*
1662 a2s (const char *plugin,
1663      const void *addr,
1664      uint16_t addr_len)
1665 {
1666   struct TransportPlugin *p;
1667
1668   if (plugin == NULL)
1669     return NULL;
1670   p = find_transport (plugin);
1671   if (p == NULL)
1672     return NULL;
1673   return p->api->address_to_string (p->api->cls,
1674                                     addr,
1675                                     addr_len);
1676 }
1677
1678
1679 /**
1680  * Mark the given FAL entry as 'connected' (and hence preferred for
1681  * sending); also mark all others for the same peer as 'not connected'
1682  * (since only one can be preferred).
1683  *
1684  * @param fal address to set to 'connected'
1685  */
1686 static void
1687 mark_address_connected (struct ForeignAddressList *fal)
1688 {
1689   struct ForeignAddressList *pos;
1690   int cnt;
1691
1692   GNUNET_assert (GNUNET_YES == fal->validated);
1693   if (fal->connected == GNUNET_YES)
1694     return; /* nothing to do */
1695   cnt = GNUNET_YES;
1696   pos = fal->ready_list->addresses;
1697   while (pos != NULL)
1698     {
1699       if (GNUNET_YES == pos->connected)
1700         {
1701 #if DEBUG_TRANSPORT
1702           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1703                       "Marking address `%s' as no longer connected (due to connect on other address)\n",
1704                       a2s (pos->ready_list->plugin->short_name,
1705                            pos->addr,
1706                            pos->addrlen));
1707 #endif
1708           GNUNET_break (cnt == GNUNET_YES);
1709           cnt = GNUNET_NO;
1710           pos->connected = GNUNET_NO;
1711           GNUNET_STATISTICS_update (stats,
1712                                     gettext_noop ("# connected addresses"),
1713                                     -1,
1714                                     GNUNET_NO);
1715         }
1716       pos = pos->next;
1717     }
1718   fal->connected = GNUNET_YES;
1719   if (GNUNET_YES == cnt)
1720     {
1721       GNUNET_STATISTICS_update (stats,
1722                                 gettext_noop ("# connected addresses"),
1723                                 1,
1724                                 GNUNET_NO);
1725     }
1726 }
1727
1728
1729 /**
1730  * Send the specified message to the specified client.  Since multiple
1731  * messages may be pending for the same client at a time, this code
1732  * makes sure that no message is lost.
1733  *
1734  * @param client client to transmit the message to
1735  * @param msg the message to send
1736  * @param may_drop can this message be dropped if the
1737  *        message queue for this client is getting far too large?
1738  */
1739 static void
1740 transmit_to_client (struct TransportClient *client,
1741                     const struct GNUNET_MessageHeader *msg, int may_drop)
1742 {
1743   struct ClientMessageQueueEntry *q;
1744   uint16_t msize;
1745
1746   if ((client->message_count >= MAX_PENDING) && (GNUNET_YES == may_drop))
1747     {
1748       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
1749                   _
1750                   ("Dropping message of type %u and size %u, have %u messages pending (%u is the soft limit)\n"),
1751                   ntohs (msg->type),
1752                   ntohs (msg->size),
1753                   client->message_count,
1754                   MAX_PENDING);
1755       GNUNET_STATISTICS_update (stats,
1756                                 gettext_noop ("# messages dropped due to slow client"),
1757                                 1,
1758                                 GNUNET_NO);
1759       return;
1760     }
1761   msize = ntohs (msg->size);
1762   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
1763   q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize);
1764   memcpy (&q[1], msg, msize);
1765   GNUNET_CONTAINER_DLL_insert_after (client->message_queue_head,
1766                                      client->message_queue_tail,
1767                                      client->message_queue_tail,
1768                                      q);
1769   client->message_count++;
1770   if (client->th == NULL)
1771     {
1772       client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
1773                                                         msize,
1774                                                         GNUNET_TIME_UNIT_FOREVER_REL,
1775                                                         &transmit_to_client_callback,
1776                                                         client);
1777       GNUNET_assert (client->th != NULL);
1778     }
1779 }
1780
1781
1782 /**
1783  * Transmit a 'SEND_OK' notification to the given client for the
1784  * given neighbour.
1785  *
1786  * @param client who to notify
1787  * @param n neighbour to notify about, can be NULL (on failure)
1788  * @param target target of the transmission
1789  * @param result status code for the transmission request
1790  */
1791 static void
1792 transmit_send_ok (struct TransportClient *client,
1793                   struct NeighbourList *n,
1794                   const struct GNUNET_PeerIdentity *target,
1795                   int result)
1796 {
1797   struct SendOkMessage send_ok_msg;
1798
1799   send_ok_msg.header.size = htons (sizeof (send_ok_msg));
1800   send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
1801   send_ok_msg.success = htonl (result);
1802   if (n != NULL)
1803     send_ok_msg.latency = GNUNET_TIME_relative_hton (n->latency);
1804   else
1805     send_ok_msg.latency = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL);
1806   send_ok_msg.peer = *target;
1807   transmit_to_client (client, &send_ok_msg.header, GNUNET_NO);
1808 }
1809
1810
1811 /**
1812  * Function called by the GNUNET_TRANSPORT_TransmitFunction
1813  * upon "completion" of a send request.  This tells the API
1814  * that it is now legal to send another message to the given
1815  * peer.
1816  *
1817  * @param cls closure, identifies the entry on the
1818  *            message queue that was transmitted and the
1819  *            client responsible for queuing the message
1820  * @param target the peer receiving the message
1821  * @param result GNUNET_OK on success, if the transmission
1822  *           failed, we should not tell the client to transmit
1823  *           more messages
1824  */
1825 static void
1826 transmit_send_continuation (void *cls,
1827                             const struct GNUNET_PeerIdentity *target,
1828                             int result)
1829 {
1830   struct MessageQueue *mq = cls;
1831   struct NeighbourList *n;
1832
1833   GNUNET_STATISTICS_update (stats,
1834                             gettext_noop ("# bytes pending with plugins"),
1835                             - (int64_t) mq->message_buf_size,
1836                             GNUNET_NO);
1837   if (result == GNUNET_OK)
1838     {
1839       GNUNET_STATISTICS_update (stats,
1840                                 gettext_noop ("# bytes successfully transmitted by plugins"),
1841                                 mq->message_buf_size,
1842                                 GNUNET_NO);
1843     }
1844   else
1845     {
1846       GNUNET_STATISTICS_update (stats,
1847                                 gettext_noop ("# bytes with transmission failure by plugins"),
1848                                 mq->message_buf_size,
1849                                 GNUNET_NO);
1850     }
1851   if (mq->specific_address != NULL)
1852     {
1853       if (result == GNUNET_OK)
1854         {
1855           mq->specific_address->timeout =
1856             GNUNET_TIME_relative_to_absolute
1857             (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
1858           if (mq->specific_address->validated == GNUNET_YES)
1859             mark_address_connected (mq->specific_address);
1860         }
1861       else
1862         {
1863           if (mq->specific_address->connected != GNUNET_NO)
1864             {
1865 #if DEBUG_TRANSPORT
1866               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1867                           "Marking address `%s' as no longer connected (due to transmission problem)\n",
1868                           a2s (mq->specific_address->ready_list->plugin->short_name,
1869                                mq->specific_address->addr,
1870                                mq->specific_address->addrlen));
1871 #endif
1872               GNUNET_STATISTICS_update (stats,
1873                                         gettext_noop ("# connected addresses"),
1874                                         -1,
1875                                         GNUNET_NO);
1876               mq->specific_address->connected = GNUNET_NO;
1877             }
1878         }
1879       if (! mq->internal_msg)
1880         mq->specific_address->in_transmit = GNUNET_NO;
1881     }
1882   n = find_neighbour(&mq->neighbour_id);
1883   if (mq->client != NULL)
1884     transmit_send_ok (mq->client, n, target, result);
1885   GNUNET_free (mq);
1886   if (n != NULL)
1887     try_transmission_to_peer (n);
1888 }
1889
1890
1891 /**
1892  * Find an address in any of the available transports for
1893  * the given neighbour that would be good for message
1894  * transmission.  This is essentially the transport selection
1895  * routine.
1896  *
1897  * @param neighbour for whom to select an address
1898  * @return selected address, NULL if we have none
1899  */
1900 struct ForeignAddressList *
1901 find_ready_address(struct NeighbourList *neighbour)
1902 {
1903   struct ReadyList *head = neighbour->plugins;
1904   struct ForeignAddressList *addresses;
1905   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
1906   struct ForeignAddressList *best_address;
1907
1908   /* Hack to prefer unix domain sockets */
1909   struct ForeignAddressList *unix_address = NULL;
1910
1911   best_address = NULL;
1912   while (head != NULL)
1913     {
1914       addresses = head->addresses;
1915       while (addresses != NULL)
1916         {
1917           if ( (addresses->timeout.abs_value < now.abs_value) &&
1918                (addresses->connected == GNUNET_YES) )
1919             {
1920 #if DEBUG_TRANSPORT
1921               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1922                           "Marking long-time inactive connection to `%4s' as down.\n",
1923                           GNUNET_i2s (&neighbour->id));
1924 #endif
1925               GNUNET_STATISTICS_update (stats,
1926                                         gettext_noop ("# connected addresses"),
1927                                         -1,
1928                                         GNUNET_NO);
1929               addresses->connected = GNUNET_NO;
1930             }
1931           addresses = addresses->next;
1932         }
1933
1934       addresses = head->addresses;
1935       while (addresses != NULL)
1936         {
1937 #if DEBUG_TRANSPORT > 1
1938           if (addresses->addr != NULL)
1939             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1940                         "Have address `%s' for peer `%4s' (status: %d, %d, %d, %u, %llums, %u)\n",
1941                         a2s (head->plugin->short_name,
1942                              addresses->addr,
1943                              addresses->addrlen),
1944                         GNUNET_i2s (&neighbour->id),
1945                         addresses->connected,
1946                         addresses->in_transmit,
1947                         addresses->validated,
1948                         addresses->connect_attempts,
1949                         (unsigned long long) addresses->timeout.abs_value,
1950                         (unsigned int) addresses->distance);
1951 #endif
1952                  if (0==strcmp(head->plugin->short_name,"unix"))
1953                  {
1954                          if ((unix_address == NULL) || ((unix_address != NULL) &&
1955                                  (addresses->latency.rel_value < unix_address->latency.rel_value)))
1956                                 unix_address = addresses;
1957                  }
1958           if ( ( (best_address == NULL) ||
1959                  (addresses->connected == GNUNET_YES) ||
1960                  (best_address->connected == GNUNET_NO) ) &&
1961                (addresses->in_transmit == GNUNET_NO) &&
1962                ( (best_address == NULL) ||
1963                  (addresses->latency.rel_value < best_address->latency.rel_value)) )
1964             best_address = addresses;
1965           /* FIXME: also give lower-latency addresses that are not
1966              connected a chance some times... */
1967           addresses = addresses->next;
1968         }
1969       if (unix_address != NULL)
1970           break;
1971       head = head->next;
1972     }
1973   if (unix_address != NULL)
1974   {
1975           best_address = unix_address;
1976 #if DEBUG_TRANSPORT
1977           GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Found unix address, forced this address\n");
1978 #endif
1979   }
1980   if (best_address != NULL)
1981     {
1982 #if DEBUG_TRANSPORT
1983
1984           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1985                   "Best address found (`%s') has latency of %llu ms.\n",
1986                   (best_address->addrlen > 0)
1987                   ? a2s (best_address->ready_list->plugin->short_name,
1988                        best_address->addr,
1989                        best_address->addrlen)
1990                   : "<inbound>",
1991                   best_address->latency.rel_value);
1992 #endif
1993     }
1994   else
1995     {
1996       GNUNET_STATISTICS_update (stats,
1997                                 gettext_noop ("# transmission attempts failed (no address)"),
1998                                 1,
1999                                 GNUNET_NO);
2000     }
2001
2002   return best_address;
2003
2004 }
2005
2006
2007 /**
2008  * We should re-try transmitting to the given peer,
2009  * hopefully we've learned something in the meantime.
2010  */
2011 static void
2012 retry_transmission_task (void *cls,
2013                          const struct GNUNET_SCHEDULER_TaskContext *tc)
2014 {
2015   struct NeighbourList *n = cls;
2016
2017   n->retry_task = GNUNET_SCHEDULER_NO_TASK;
2018   try_transmission_to_peer (n);
2019 }
2020
2021
2022 /**
2023  * Check the ready list for the given neighbour and if a plugin is
2024  * ready for transmission (and if we have a message), do so!
2025  *
2026  * @param neighbour target peer for which to transmit
2027  */
2028 static void
2029 try_transmission_to_peer (struct NeighbourList *n)
2030 {
2031   struct ReadyList *rl;
2032   struct MessageQueue *mq;
2033   struct GNUNET_TIME_Relative timeout;
2034   ssize_t ret;
2035   int force_address;
2036
2037   if (n->messages_head == NULL)
2038     {
2039 #if DEBUG_TRANSPORT
2040       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2041                   "Transmission queue for `%4s' is empty\n",
2042                   GNUNET_i2s (&n->id));
2043 #endif
2044       return;                     /* nothing to do */
2045     }
2046   rl = NULL;
2047   mq = n->messages_head;
2048   force_address = GNUNET_YES;
2049   if (mq->specific_address == NULL)
2050     {
2051           /* TODO: ADD ATS */
2052       mq->specific_address = ats_get_preferred_address(n);
2053       GNUNET_STATISTICS_update (stats,
2054                                 gettext_noop ("# transport selected peer address freely"),
2055                                 1,
2056                                 GNUNET_NO);
2057       force_address = GNUNET_NO;
2058     }
2059   if (mq->specific_address == NULL)
2060     {
2061       GNUNET_STATISTICS_update (stats,
2062                                 gettext_noop ("# transport failed to selected peer address"),
2063                                 1,
2064                                 GNUNET_NO);
2065       timeout = GNUNET_TIME_absolute_get_remaining (mq->timeout);
2066       if (timeout.rel_value == 0)
2067         {
2068 #if DEBUG_TRANSPORT
2069           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2070                       "No destination address available to transmit message of size %u to peer `%4s'\n",
2071                       mq->message_buf_size,
2072                       GNUNET_i2s (&mq->neighbour_id));
2073 #endif
2074           GNUNET_STATISTICS_update (stats,
2075                                     gettext_noop ("# bytes in message queue for other peers"),
2076                                     - (int64_t) mq->message_buf_size,
2077                                     GNUNET_NO);
2078           GNUNET_STATISTICS_update (stats,
2079                                     gettext_noop ("# bytes discarded (no destination address available)"),
2080                                     mq->message_buf_size,
2081                                     GNUNET_NO);
2082           if (mq->client != NULL)
2083             transmit_send_ok (mq->client, n, &n->id, GNUNET_NO);
2084           GNUNET_CONTAINER_DLL_remove (n->messages_head,
2085                                        n->messages_tail,
2086                                        mq);
2087           GNUNET_free (mq);
2088           return;               /* nobody ready */
2089         }
2090       GNUNET_STATISTICS_update (stats,
2091                                 gettext_noop ("# message delivery deferred (no address)"),
2092                                 1,
2093                                 GNUNET_NO);
2094       if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
2095         GNUNET_SCHEDULER_cancel (n->retry_task);
2096       n->retry_task = GNUNET_SCHEDULER_add_delayed (timeout,
2097                                                             &retry_transmission_task,
2098                                                             n);
2099 #if DEBUG_TRANSPORT
2100       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2101                   "No validated destination address available to transmit message of size %u to peer `%4s', will wait %llums to find an address.\n",
2102                   mq->message_buf_size,
2103                   GNUNET_i2s (&mq->neighbour_id),
2104                   timeout.rel_value);
2105 #endif
2106       /* FIXME: might want to trigger peerinfo lookup here
2107          (unless that's already pending...) */
2108       return;
2109     }
2110   GNUNET_CONTAINER_DLL_remove (n->messages_head,
2111                                n->messages_tail,
2112                                mq);
2113   if (mq->specific_address->connected == GNUNET_NO)
2114     mq->specific_address->connect_attempts++;
2115   rl = mq->specific_address->ready_list;
2116   mq->plugin = rl->plugin;
2117   if (!mq->internal_msg)
2118     mq->specific_address->in_transmit = GNUNET_YES;
2119 #if DEBUG_TRANSPORT
2120   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2121               "Sending message of size %u for `%4s' to `%s' via plugin `%s'\n",
2122               mq->message_buf_size,
2123               GNUNET_i2s (&n->id),
2124               (mq->specific_address->addr != NULL)
2125               ? a2s (mq->plugin->short_name,
2126                      mq->specific_address->addr,
2127                      mq->specific_address->addrlen)
2128               : "<inbound>",
2129               rl->plugin->short_name);
2130 #endif
2131   GNUNET_STATISTICS_update (stats,
2132                             gettext_noop ("# bytes in message queue for other peers"),
2133                             - (int64_t) mq->message_buf_size,
2134                             GNUNET_NO);
2135   GNUNET_STATISTICS_update (stats,
2136                             gettext_noop ("# bytes pending with plugins"),
2137                             mq->message_buf_size,
2138                             GNUNET_NO);
2139   ret = rl->plugin->api->send (rl->plugin->api->cls,
2140                                &mq->neighbour_id,
2141                                mq->message_buf,
2142                                mq->message_buf_size,
2143                                mq->priority,
2144                                GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2145                                mq->specific_address->session,
2146                                mq->specific_address->addr,
2147                                mq->specific_address->addrlen,
2148                                force_address,
2149                                &transmit_send_continuation, mq);
2150   if (ret == -1)
2151     {
2152       /* failure, but 'send' would not call continuation in this case,
2153          so we need to do it here! */
2154       transmit_send_continuation (mq,
2155                                   &mq->neighbour_id,
2156                                   GNUNET_SYSERR);
2157     }
2158 }
2159
2160
2161 /**
2162  * Send the specified message to the specified peer.
2163  *
2164  * @param client source of the transmission request (can be NULL)
2165  * @param peer_address ForeignAddressList where we should send this message
2166  * @param priority how important is the message
2167  * @param timeout how long do we have to transmit?
2168  * @param message_buf message(s) to send GNUNET_MessageHeader(s)
2169  * @param message_buf_size total size of all messages in message_buf
2170  * @param is_internal is this an internal message; these are pre-pended and
2171  *                    also do not count for plugins being "ready" to transmit
2172  * @param neighbour handle to the neighbour for transmission
2173  */
2174 static void
2175 transmit_to_peer (struct TransportClient *client,
2176                   struct ForeignAddressList *peer_address,
2177                   unsigned int priority,
2178                   struct GNUNET_TIME_Relative timeout,
2179                   const char *message_buf,
2180                   size_t message_buf_size,
2181                   int is_internal, struct NeighbourList *neighbour)
2182 {
2183   struct MessageQueue *mq;
2184
2185 #if EXTRA_CHECKS
2186   if (client != NULL)
2187     {
2188       /* check for duplicate submission */
2189       mq = neighbour->messages_head;
2190       while (NULL != mq)
2191         {
2192           if (mq->client == client)
2193             {
2194               /* client transmitted to same peer twice
2195                  before getting SEND_OK! */
2196               GNUNET_break (0);
2197               return;
2198             }
2199           mq = mq->next;
2200         }
2201     }
2202 #endif
2203   GNUNET_STATISTICS_update (stats,
2204                             gettext_noop ("# bytes in message queue for other peers"),
2205                             message_buf_size,
2206                             GNUNET_NO);
2207   mq = GNUNET_malloc (sizeof (struct MessageQueue) + message_buf_size);
2208   mq->specific_address = peer_address;
2209   mq->client = client;
2210   /* FIXME: this memcpy can be up to 7% of our total runtime! */
2211   memcpy (&mq[1], message_buf, message_buf_size);
2212   mq->message_buf = (const char*) &mq[1];
2213   mq->message_buf_size = message_buf_size;
2214   memcpy(&mq->neighbour_id, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
2215   mq->internal_msg = is_internal;
2216   mq->priority = priority;
2217   mq->timeout = GNUNET_TIME_relative_to_absolute (timeout);
2218   if (is_internal)
2219     GNUNET_CONTAINER_DLL_insert (neighbour->messages_head,
2220                                  neighbour->messages_tail,
2221                                  mq);
2222   else
2223     GNUNET_CONTAINER_DLL_insert_after (neighbour->messages_head,
2224                                        neighbour->messages_tail,
2225                                        neighbour->messages_tail,
2226                                        mq);
2227   try_transmission_to_peer (neighbour);
2228 }
2229
2230
2231 /**
2232  * FIXME: document.
2233  */
2234 struct GeneratorContext
2235 {
2236   struct TransportPlugin *plug_pos;
2237   struct OwnAddressList *addr_pos;
2238   struct GNUNET_TIME_Absolute expiration;
2239 };
2240
2241
2242 /**
2243  * FIXME: document.
2244  */
2245 static size_t
2246 address_generator (void *cls, size_t max, void *buf)
2247 {
2248   struct GeneratorContext *gc = cls;
2249   size_t ret;
2250
2251   while ((gc->addr_pos == NULL) && (gc->plug_pos != NULL))
2252     {
2253       gc->plug_pos = gc->plug_pos->next;
2254       gc->addr_pos = (gc->plug_pos != NULL) ? gc->plug_pos->addresses : NULL;
2255     }
2256   if (NULL == gc->plug_pos)
2257     {
2258
2259       return 0;
2260     }
2261   ret = GNUNET_HELLO_add_address (gc->plug_pos->short_name,
2262                                   gc->expiration,
2263                                   &gc->addr_pos[1],
2264                                   gc->addr_pos->addrlen, buf, max);
2265   gc->addr_pos = gc->addr_pos->next;
2266   return ret;
2267 }
2268
2269
2270 /**
2271  * Construct our HELLO message from all of the addresses of
2272  * all of the transports.
2273  */
2274 static void
2275 refresh_hello ()
2276 {
2277   struct GNUNET_HELLO_Message *hello;
2278   struct TransportClient *cpos;
2279   struct NeighbourList *npos;
2280   struct GeneratorContext gc;
2281
2282   gc.plug_pos = plugins;
2283   gc.addr_pos = plugins != NULL ? plugins->addresses : NULL;
2284   gc.expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
2285   hello = GNUNET_HELLO_create (&my_public_key, &address_generator, &gc);
2286 #if DEBUG_TRANSPORT
2287   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
2288               "Refreshed my `%s', new size is %d\n", "HELLO", GNUNET_HELLO_size(hello));
2289 #endif
2290   GNUNET_STATISTICS_update (stats,
2291                             gettext_noop ("# refreshed my HELLO"),
2292                             1,
2293                             GNUNET_NO);
2294   cpos = clients;
2295   while (cpos != NULL)
2296     {
2297       transmit_to_client (cpos,
2298                           (const struct GNUNET_MessageHeader *) hello,
2299                           GNUNET_NO);
2300       cpos = cpos->next;
2301     }
2302
2303   GNUNET_free_non_null (our_hello);
2304   our_hello = hello;
2305   GNUNET_PEERINFO_add_peer (peerinfo, our_hello);
2306   npos = neighbours;
2307   while (npos != NULL)
2308     {
2309 #if DEBUG_TRANSPORT
2310       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
2311                   "Transmitting updated `%s' to neighbour `%4s'\n",
2312                   "HELLO", GNUNET_i2s (&npos->id));
2313 #endif
2314       GNUNET_STATISTICS_update (stats,
2315                                 gettext_noop ("# transmitted my HELLO to other peers"),
2316                                 1,
2317                                 GNUNET_NO);
2318       transmit_to_peer (NULL, NULL, 0,
2319                         HELLO_ADDRESS_EXPIRATION,
2320                         (const char *) our_hello,
2321                         GNUNET_HELLO_size(our_hello),
2322                         GNUNET_NO, npos);
2323       npos = npos->next;
2324     }
2325 }
2326
2327
2328 /**
2329  * Task used to clean up expired addresses for a plugin.
2330  *
2331  * @param cls closure
2332  * @param tc context
2333  */
2334 static void
2335 expire_address_task (void *cls,
2336                      const struct GNUNET_SCHEDULER_TaskContext *tc);
2337
2338
2339 /**
2340  * Update the list of addresses for this plugin,
2341  * expiring those that are past their expiration date.
2342  *
2343  * @param plugin addresses of which plugin should be recomputed?
2344  * @param fresh set to GNUNET_YES if a new address was added
2345  *        and we need to regenerate the HELLO even if nobody
2346  *        expired
2347  */
2348 static void
2349 update_addresses (struct TransportPlugin *plugin,
2350                   int fresh)
2351 {
2352   static struct GNUNET_TIME_Absolute last_update;
2353   struct GNUNET_TIME_Relative min_remaining;
2354   struct GNUNET_TIME_Relative remaining;
2355   struct GNUNET_TIME_Absolute now;
2356   struct OwnAddressList *pos;
2357   struct OwnAddressList *prev;
2358   struct OwnAddressList *next;
2359   int expired;
2360
2361   if (plugin->address_update_task != GNUNET_SCHEDULER_NO_TASK)
2362     GNUNET_SCHEDULER_cancel (plugin->address_update_task);
2363   plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
2364   now = GNUNET_TIME_absolute_get ();
2365   min_remaining = GNUNET_TIME_UNIT_FOREVER_REL;
2366   expired = (GNUNET_TIME_absolute_get_duration (last_update).rel_value > (HELLO_ADDRESS_EXPIRATION.rel_value / 4));
2367   prev = NULL;
2368   pos = plugin->addresses;
2369   while (pos != NULL)
2370     {
2371       next = pos->next;
2372       if (pos->expires.abs_value < now.abs_value)
2373         {
2374           expired = GNUNET_YES;
2375           if (prev == NULL)
2376             plugin->addresses = pos->next;
2377           else
2378             prev->next = pos->next;
2379           GNUNET_free (pos);
2380         }
2381       else
2382         {
2383           remaining = GNUNET_TIME_absolute_get_remaining (pos->expires);
2384           if (remaining.rel_value < min_remaining.rel_value)
2385             min_remaining = remaining;
2386           prev = pos;
2387         }
2388       pos = next;
2389     }
2390
2391   if (expired || fresh)
2392     {
2393       last_update = now;
2394       refresh_hello ();
2395     }
2396   min_remaining = GNUNET_TIME_relative_min (min_remaining,
2397                                             GNUNET_TIME_relative_divide (HELLO_ADDRESS_EXPIRATION,
2398                                                                          2));
2399   plugin->address_update_task
2400     = GNUNET_SCHEDULER_add_delayed (min_remaining,
2401                                     &expire_address_task, plugin);
2402 }
2403
2404
2405 /**
2406  * Task used to clean up expired addresses for a plugin.
2407  *
2408  * @param cls closure
2409  * @param tc context
2410  */
2411 static void
2412 expire_address_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2413 {
2414   struct TransportPlugin *plugin = cls;
2415
2416   plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
2417   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2418     update_addresses (plugin, GNUNET_NO);
2419 }
2420
2421
2422 /**
2423  * Iterator over hash map entries that NULLs the session of validation
2424  * entries that match the given session.
2425  *
2426  * @param cls closure (the 'struct Session*' to match against)
2427  * @param key current key code (peer ID, not used)
2428  * @param value value in the hash map ('struct ValidationEntry*')
2429  * @return GNUNET_YES (we should continue to iterate)
2430  */
2431 static int
2432 remove_session_validations (void *cls,
2433                             const GNUNET_HashCode * key,
2434                             void *value)
2435 {
2436   struct Session *session = cls;
2437   struct ValidationEntry *ve = value;
2438
2439   if (session == ve->session)
2440     ve->session = NULL;
2441   return GNUNET_YES;
2442 }
2443
2444
2445 /**
2446  * We've been disconnected from the other peer (for some
2447  * connection-oriented transport).  Either quickly
2448  * re-establish the connection or signal the disconnect
2449  * to the CORE.
2450  *
2451  * Only signal CORE level disconnect if ALL addresses
2452  * for the peer are exhausted.
2453  *
2454  * @param p overall plugin context
2455  * @param nl neighbour that was disconnected
2456  */
2457 static void
2458 try_fast_reconnect (struct TransportPlugin *p,
2459                     struct NeighbourList *nl)
2460 {
2461   /* FIXME-MW: fast reconnect / transport switching not implemented... */
2462   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2463               "try_fast_reconnect not implemented!\n");
2464   /* Note: the idea here is to hide problems with transports (or
2465      switching between plugins) from the core to eliminate the need to
2466      re-negotiate session keys and the like; OTOH, we should tell core
2467      quickly (much faster than timeout) `if a connection was lost and
2468      could not be re-established (i.e. other peer went down or is
2469      unable / refuses to communicate);
2470
2471      So we should consider:
2472      1) ideally: our own willingness / need to connect
2473      2) prior failures to connect to this peer (by plugin)
2474      3) ideally: reasons why other peer terminated (as far as knowable)
2475
2476      Most importantly, it must be POSSIBLE for another peer to terminate
2477      a connection for a while (without us instantly re-establishing it).
2478      Similarly, if another peer is gone we should quickly notify CORE.
2479      OTOH, if there was a minor glitch (i.e. crash of gnunet-service-transport
2480      on the other end), we should reconnect in such a way that BOTH CORE
2481      services never even notice.
2482      Furthermore, the same mechanism (or small variation) could be used
2483      to switch to a better-performing plugin (ATS).
2484
2485      Finally, this needs to be tested throughly... */
2486
2487   /*
2488    * GNUNET_NO in the call below makes transport disconnect the peer,
2489    * even if only a single address (out of say, six) went away.  This
2490    * function must be careful to ONLY disconnect if the peer is gone,
2491    * not just a specifi address.
2492    *
2493    * More specifically, half the places it was used had it WRONG.
2494    */
2495
2496   /* No reconnect, signal disconnect instead! */
2497 #if DEBUG_TRANSPORT
2498   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2499             "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&nl->id),
2500             "try_fast_reconnect");
2501 #endif
2502   disconnect_neighbour (nl, GNUNET_YES);
2503 }
2504
2505
2506 /**
2507  * Function that will be called whenever the plugin internally
2508  * cleans up a session pointer and hence the service needs to
2509  * discard all of those sessions as well.  Plugins that do not
2510  * use sessions can simply omit calling this function and always
2511  * use NULL wherever a session pointer is needed.
2512  *
2513  * @param cls closure
2514  * @param peer which peer was the session for
2515  * @param session which session is being destoyed
2516  */
2517 static void
2518 plugin_env_session_end  (void *cls,
2519                          const struct GNUNET_PeerIdentity *peer,
2520                          struct Session *session)
2521 {
2522   struct TransportPlugin *p = cls;
2523   struct NeighbourList *nl;
2524   struct ReadyList *rl;
2525   struct ForeignAddressList *pos;
2526   struct ForeignAddressList *prev;
2527
2528 #if DEBUG_TRANSPORT
2529   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2530               "Session ended with peer `%4s', %s\n",
2531               GNUNET_i2s(peer),
2532               "plugin_env_session_end");
2533 #endif
2534   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
2535                                          &remove_session_validations,
2536                                          session);
2537   nl = find_neighbour (peer);
2538   if (nl == NULL)
2539     {
2540 #if DEBUG_TRANSPORT
2541       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2542                   "No neighbour record found for peer `%4s'\n",
2543                   GNUNET_i2s(peer));
2544 #endif
2545       return; /* was never marked as connected */
2546     }
2547   rl = nl->plugins;
2548   while (rl != NULL)
2549     {
2550       if (rl->plugin == p)
2551         break;
2552       rl = rl->next;
2553     }
2554   if (rl == NULL)
2555     {
2556 #if DEBUG_TRANSPORT
2557       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2558                   "Plugin was associated with peer `%4s'\n",
2559                   GNUNET_i2s(peer));
2560 #endif
2561       disconnect_neighbour (nl, GNUNET_YES);
2562       return;
2563     }
2564   prev = NULL;
2565   pos = rl->addresses;
2566   while ( (pos != NULL) &&
2567           (pos->session != session) )
2568     {
2569       prev = pos;
2570       pos = pos->next;
2571     }
2572   if (pos == NULL)
2573     {
2574 #if DEBUG_TRANSPORT
2575       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2576                   "Session was never marked as ready for peer `%4s'\n",
2577                   GNUNET_i2s(peer));
2578 #endif
2579       //FIXME: This conflicts with inbound tcp connections and tcp nat ... debugging in progress
2580       //disconnect_neighbour (nl, GNUNET_YES);
2581       return; /* was never marked as connected */
2582     }
2583   pos->session = NULL;
2584   if (pos->addrlen != 0)
2585     {
2586       if (nl->received_pong != GNUNET_NO)
2587         try_fast_reconnect (p, nl);
2588       else
2589         disconnect_neighbour (nl, GNUNET_YES);
2590       return;
2591     }
2592   /* was inbound connection, free 'pos' */
2593   if (prev == NULL)
2594     rl->addresses = pos->next;
2595   else
2596     prev->next = pos->next;
2597   if (GNUNET_SCHEDULER_NO_TASK != pos->revalidate_task)
2598     {
2599       GNUNET_SCHEDULER_cancel (pos->revalidate_task);
2600       pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
2601     }
2602   GNUNET_free_non_null(pos->ressources);
2603   GNUNET_free_non_null(pos->quality);
2604   GNUNET_free (pos);
2605   ats->stat.recreate_problem = GNUNET_YES;
2606   if (nl->received_pong == GNUNET_NO)
2607     {
2608       disconnect_neighbour (nl, GNUNET_YES);
2609       return; /* nothing to do, never connected... */
2610     }
2611   /* check if we have any validated addresses left */
2612   pos = rl->addresses;
2613   while (pos != NULL)
2614     {
2615       if (pos->validated)
2616         {
2617           try_fast_reconnect (p, nl);
2618           return;
2619         }
2620       pos = pos->next;
2621     }
2622   /* no valid addresses left, signal disconnect! */
2623
2624 #if DEBUG_TRANSPORT
2625   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2626               "Disconnecting peer `%4s', %s\n",
2627               GNUNET_i2s(peer),
2628               "plugin_env_session_end");
2629 #endif
2630   /* FIXME: This doesn't mean there are no addresses left for this PEER,
2631    * it means there aren't any left for this PLUGIN/PEER combination! So
2632    * calling disconnect_neighbour here with GNUNET_NO forces disconnect
2633    * when it isn't necessary. Using GNUNET_YES at least checks to see
2634    * if there are any addresses that work first, so as not to overdo it.
2635    * --NE
2636    */
2637   disconnect_neighbour (nl, GNUNET_YES);
2638 }
2639
2640
2641 /**
2642  * Function that must be called by each plugin to notify the
2643  * transport service about the addresses under which the transport
2644  * provided by the plugin can be reached.
2645  *
2646  * @param cls closure
2647  * @param name name of the transport that generated the address
2648  * @param addr one of the addresses of the host, NULL for the last address
2649  *        the specific address format depends on the transport
2650  * @param addrlen length of the address
2651  * @param expires when should this address automatically expire?
2652  */
2653 static void
2654 plugin_env_notify_address (void *cls,
2655                            const char *name,
2656                            const void *addr,
2657                            uint16_t addrlen,
2658                            struct GNUNET_TIME_Relative expires)
2659 {
2660   struct TransportPlugin *p = cls;
2661   struct OwnAddressList *al;
2662   struct GNUNET_TIME_Absolute abex;
2663
2664   GNUNET_assert (addr != NULL);
2665   abex = GNUNET_TIME_relative_to_absolute (expires);
2666   GNUNET_assert (p == find_transport (name));
2667   al = p->addresses;
2668   while (al != NULL)
2669     {
2670       if ( (addrlen == al->addrlen) &&
2671            (0 == memcmp (addr, &al[1], addrlen)) )
2672         {
2673           al->expires = abex;
2674           update_addresses (p, GNUNET_NO);
2675           return;
2676         }
2677       al = al->next;
2678     }
2679   al = GNUNET_malloc (sizeof (struct OwnAddressList) + addrlen);
2680   al->next = p->addresses;
2681   p->addresses = al;
2682   al->expires = abex;
2683   al->addrlen = addrlen;
2684   memcpy (&al[1], addr, addrlen);
2685   update_addresses (p, GNUNET_YES);
2686 }
2687
2688
2689 /**
2690  * Notify all of our clients about a peer connecting.
2691  */
2692 static void
2693 notify_clients_connect (const struct GNUNET_PeerIdentity *peer,
2694                         struct GNUNET_TIME_Relative latency,
2695                         uint32_t distance)
2696 {
2697   struct ConnectInfoMessage * cim;
2698   struct TransportClient *cpos;
2699   uint32_t ats_count;
2700   size_t size;
2701
2702 #if DEBUG_TRANSPORT
2703   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2704               "Notifying clients about connection from `%s'\n",
2705               GNUNET_i2s (peer));
2706 #endif
2707   GNUNET_STATISTICS_update (stats,
2708                             gettext_noop ("# peers connected"),
2709                             1,
2710                             GNUNET_NO);
2711
2712   ats_count = 2;
2713   size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
2714   if (size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
2715   {
2716           GNUNET_break(0);
2717   }
2718   cim = GNUNET_malloc (size);
2719
2720   cim->header.size = htons (size);
2721   cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
2722   cim->ats_count = htonl(2);
2723   (&(cim->ats))[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
2724   (&(cim->ats))[0].value = htonl (distance);
2725   (&(cim->ats))[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
2726   (&(cim->ats))[1].value = htonl ((uint32_t) latency.rel_value);
2727   (&(cim->ats))[2].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
2728   (&(cim->ats))[2].value = htonl (0);
2729   memcpy (&cim->id, peer, sizeof (struct GNUNET_PeerIdentity));
2730
2731   /* notify ats about connecting peer */
2732   ats_notify_peer_connect (peer, &(cim->ats), 2);
2733
2734   cpos = clients;
2735   while (cpos != NULL)
2736     {
2737       transmit_to_client (cpos, &(cim->header), GNUNET_NO);
2738       cpos = cpos->next;
2739     }
2740
2741   GNUNET_free (cim);
2742 }
2743
2744
2745 /**
2746  * Notify all of our clients about a peer disconnecting.
2747  */
2748 static void
2749 notify_clients_disconnect (const struct GNUNET_PeerIdentity *peer)
2750 {
2751   struct DisconnectInfoMessage dim;
2752   struct TransportClient *cpos;
2753
2754 #if DEBUG_TRANSPORT
2755   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2756               "Notifying clients about lost connection to `%s'\n",
2757               GNUNET_i2s (peer));
2758 #endif
2759   GNUNET_STATISTICS_update (stats,
2760                             gettext_noop ("# peers connected"),
2761                             -1,
2762                             GNUNET_NO);
2763   dim.header.size = htons (sizeof (struct DisconnectInfoMessage));
2764   dim.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
2765   dim.reserved = htonl (0);
2766   memcpy (&dim.peer, peer, sizeof (struct GNUNET_PeerIdentity));
2767
2768   /* notify ats about connecting peer */
2769   ats_notify_peer_disconnect (peer);
2770
2771   cpos = clients;
2772   while (cpos != NULL)
2773     {
2774       transmit_to_client (cpos, &dim.header, GNUNET_NO);
2775       cpos = cpos->next;
2776     }
2777 }
2778
2779
2780 /**
2781  * Find a ForeignAddressList entry for the given neighbour
2782  * that matches the given address and transport.
2783  *
2784  * @param neighbour which peer we care about
2785  * @param tname name of the transport plugin
2786  * @param session session to look for, NULL for 'any'; otherwise
2787  *        can be used for the service to "learn" this session ID
2788  *        if 'addr' matches
2789  * @param addr binary address
2790  * @param addrlen length of addr
2791  * @return NULL if no such entry exists
2792  */
2793 static struct ForeignAddressList *
2794 find_peer_address(struct NeighbourList *neighbour,
2795                   const char *tname,
2796                   struct Session *session,
2797                   const char *addr,
2798                   uint16_t addrlen)
2799 {
2800   struct ReadyList *head;
2801   struct ForeignAddressList *pos;
2802
2803   head = neighbour->plugins;
2804   while (head != NULL)
2805     {
2806       if (0 == strcmp (tname, head->plugin->short_name))
2807         break;
2808       head = head->next;
2809     }
2810   if (head == NULL)
2811     return NULL;
2812   pos = head->addresses;
2813   while ( (pos != NULL) &&
2814           ( (pos->addrlen != addrlen) ||
2815             (memcmp(pos->addr, addr, addrlen) != 0) ) )
2816     {
2817       if ( (session != NULL) &&
2818            (pos->session == session) )
2819         return pos;
2820       pos = pos->next;
2821     }
2822   if ( (session != NULL) && (pos != NULL) )
2823     pos->session = session; /* learn it! */
2824   return pos;
2825 }
2826
2827
2828 /**
2829  * Get the peer address struct for the given neighbour and
2830  * address.  If it doesn't yet exist, create it.
2831  *
2832  * @param neighbour which peer we care about
2833  * @param tname name of the transport plugin
2834  * @param session session of the plugin, or NULL for none
2835  * @param addr binary address
2836  * @param addrlen length of addr
2837  * @return NULL if we do not have a transport plugin for 'tname'
2838  */
2839 static struct ForeignAddressList *
2840 add_peer_address (struct NeighbourList *neighbour,
2841                   const char *tname,
2842                   struct Session *session,
2843                   const char *addr,
2844                   uint16_t addrlen)
2845 {
2846   struct ReadyList *head;
2847   struct ForeignAddressList *ret;
2848   int c;
2849
2850   ret = find_peer_address (neighbour, tname, session, addr, addrlen);
2851   if (ret != NULL)
2852     return ret;
2853   head = neighbour->plugins;
2854
2855   while (head != NULL)
2856     {
2857       if (0 == strcmp (tname, head->plugin->short_name))
2858         break;
2859       head = head->next;
2860     }
2861   if (head == NULL)
2862     return NULL;
2863   ret = GNUNET_malloc(sizeof(struct ForeignAddressList) + addrlen);
2864   ret->session = session;
2865   if ((addrlen > 0) && (addr != NULL))
2866     {
2867       ret->addr = (const char*) &ret[1];
2868       memcpy (&ret[1], addr, addrlen);
2869     }
2870   else
2871     {
2872       ret->addr = NULL;
2873     }
2874
2875   ret->ressources = GNUNET_malloc(available_ressources * sizeof (struct ATS_ressource_entry));
2876   for (c=0; c<available_ressources; c++)
2877     {
2878       struct ATS_ressource_entry *r = ret->ressources;
2879       r[c].index = c;
2880       r[c].atis_index = ressources[c].atis_index;
2881       if (0 == strcmp(neighbour->plugins->plugin->short_name,"unix"))
2882         {
2883           r[c].c = ressources[c].c_unix;
2884         }
2885       else if (0 == strcmp(neighbour->plugins->plugin->short_name,"udp"))
2886         {
2887           r[c].c = ressources[c].c_udp;
2888         }
2889       else if (0 == strcmp(neighbour->plugins->plugin->short_name,"tcp"))
2890         {
2891           r[c].c = ressources[c].c_tcp;
2892         }
2893       else if (0 == strcmp(neighbour->plugins->plugin->short_name,"http"))
2894         {
2895           r[c].c = ressources[c].c_http;
2896         }
2897       else if (0 == strcmp(neighbour->plugins->plugin->short_name,"https"))
2898         {
2899           r[c].c = ressources[c].c_https;
2900         }
2901       else if (0 == strcmp(neighbour->plugins->plugin->short_name,"wlan"))
2902         {
2903           r[c].c = ressources[c].c_wlan;
2904         }
2905       else
2906         {
2907           r[c].c = ressources[c].c_default;
2908           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2909                       "Assigning default cost to peer `%s' addr plugin `%s'! This should not happen!\n",
2910                       GNUNET_i2s(&neighbour->peer),
2911                       neighbour->plugins->plugin->short_name);
2912         }
2913     }
2914
2915   ret->quality = GNUNET_malloc (available_quality_metrics * sizeof (struct ATS_quality_entry));
2916   ret->addrlen = addrlen;
2917   ret->expires = GNUNET_TIME_relative_to_absolute
2918     (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
2919   ret->latency = GNUNET_TIME_relative_get_forever();
2920   ret->distance = -1;
2921   ret->timeout = GNUNET_TIME_relative_to_absolute
2922     (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
2923   ret->ready_list = head;
2924   ret->next = head->addresses;
2925   head->addresses = ret;
2926   return ret;
2927 }
2928
2929
2930 /**
2931  * Closure for 'add_validated_address'.
2932  */
2933 struct AddValidatedAddressContext
2934 {
2935   /**
2936    * Entry that has been validated.
2937    */
2938   const struct ValidationEntry *ve;
2939
2940   /**
2941    * Flag set after we have added the address so
2942    * that we terminate the iteration next time.
2943    */
2944   int done;
2945 };
2946
2947
2948 /**
2949  * Callback function used to fill a buffer of max bytes with a list of
2950  * addresses in the format used by HELLOs.  Should use
2951  * "GNUNET_HELLO_add_address" as a helper function.
2952  *
2953  * @param cls the 'struct AddValidatedAddressContext' with the validated address
2954  * @param max maximum number of bytes that can be written to buf
2955  * @param buf where to write the address information
2956  * @return number of bytes written, 0 to signal the
2957  *         end of the iteration.
2958  */
2959 static size_t
2960 add_validated_address (void *cls,
2961                        size_t max, void *buf)
2962 {
2963   struct AddValidatedAddressContext *avac = cls;
2964   const struct ValidationEntry *ve = avac->ve;
2965
2966   if (GNUNET_YES == avac->done)
2967     return 0;
2968   avac->done = GNUNET_YES;
2969   return GNUNET_HELLO_add_address (ve->transport_name,
2970                                    GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION),
2971                                    ve->addr,
2972                                    ve->addrlen,
2973                                    buf,
2974                                    max);
2975 }
2976
2977
2978
2979 /**
2980  * Closure for 'check_address_exists'.
2981  */
2982 struct CheckAddressExistsClosure
2983 {
2984   /**
2985    * Address to check for.
2986    */
2987   const void *addr;
2988
2989   /**
2990    * Name of the transport.
2991    */
2992   const char *tname;
2993
2994   /**
2995    * Session, or NULL.
2996    */
2997   struct Session *session;
2998
2999   /**
3000    * Set to GNUNET_YES if the address exists.
3001    */
3002   int exists;
3003
3004   /**
3005    * Length of addr.
3006    */
3007   uint16_t addrlen;
3008
3009 };
3010
3011
3012 /**
3013  * Iterator over hash map entries.  Checks if the given
3014  * validation entry is for the same address as what is given
3015  * in the closure.
3016  *
3017  * @param cls the 'struct CheckAddressExistsClosure*'
3018  * @param key current key code (ignored)
3019  * @param value value in the hash map ('struct ValidationEntry')
3020  * @return GNUNET_YES if we should continue to
3021  *         iterate (mismatch), GNUNET_NO if not (entry matched)
3022  */
3023 static int
3024 check_address_exists (void *cls,
3025                       const GNUNET_HashCode * key,
3026                       void *value)
3027 {
3028   struct CheckAddressExistsClosure *caec = cls;
3029   struct ValidationEntry *ve = value;
3030
3031   if ( (0 == strcmp (caec->tname,
3032                      ve->transport_name)) &&
3033        (caec->addrlen == ve->addrlen) &&
3034        (0 == memcmp (caec->addr,
3035                      ve->addr,
3036                      caec->addrlen)) )
3037     {
3038       caec->exists = GNUNET_YES;
3039       return GNUNET_NO;
3040     }
3041   if ( (ve->session != NULL) &&
3042        (caec->session == ve->session) )
3043     {
3044       caec->exists = GNUNET_YES;
3045       return GNUNET_NO;
3046     }
3047   return GNUNET_YES;
3048 }
3049
3050
3051
3052 /**
3053  * Iterator to free entries in the validation_map.
3054  *
3055  * @param cls closure (unused)
3056  * @param key current key code
3057  * @param value value in the hash map (validation to abort)
3058  * @return GNUNET_YES (always)
3059  */
3060 static int
3061 abort_validation (void *cls,
3062                   const GNUNET_HashCode * key,
3063                   void *value)
3064 {
3065   struct ValidationEntry *va = value;
3066
3067   if (GNUNET_SCHEDULER_NO_TASK != va->timeout_task)
3068     GNUNET_SCHEDULER_cancel (va->timeout_task);
3069   GNUNET_free (va->transport_name);
3070   if (va->chvc != NULL)
3071     {
3072       va->chvc->ve_count--;
3073       if (va->chvc->ve_count == 0)
3074         {
3075           GNUNET_CONTAINER_DLL_remove (chvc_head,
3076                                        chvc_tail,
3077                                        va->chvc);
3078           GNUNET_free (va->chvc);
3079         }
3080       va->chvc = NULL;
3081     }
3082   GNUNET_free (va);
3083   return GNUNET_YES;
3084 }
3085
3086
3087 /**
3088  * HELLO validation cleanup task (validation failed).
3089  *
3090  * @param cls the 'struct ValidationEntry' that failed
3091  * @param tc scheduler context (unused)
3092  */
3093 static void
3094 timeout_hello_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
3095 {
3096   struct ValidationEntry *va = cls;
3097   struct GNUNET_PeerIdentity pid;
3098
3099   va->timeout_task = GNUNET_SCHEDULER_NO_TASK;
3100   GNUNET_STATISTICS_update (stats,
3101                             gettext_noop ("# address validation timeouts"),
3102                             1,
3103                             GNUNET_NO);
3104   GNUNET_CRYPTO_hash (&va->publicKey,
3105                       sizeof (struct
3106                               GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
3107                       &pid.hashPubKey);
3108   GNUNET_break (GNUNET_OK ==
3109                 GNUNET_CONTAINER_multihashmap_remove (validation_map,
3110                                                       &pid.hashPubKey,
3111                                                       va));
3112   abort_validation (NULL, NULL, va);
3113 }
3114
3115
3116 static void
3117 neighbour_timeout_task (void *cls,
3118                        const struct GNUNET_SCHEDULER_TaskContext *tc)
3119 {
3120   struct NeighbourList *n = cls;
3121
3122 #if DEBUG_TRANSPORT
3123   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
3124               "Neighbour `%4s' has timed out!\n", GNUNET_i2s (&n->id));
3125 #endif
3126   GNUNET_STATISTICS_update (stats,
3127                             gettext_noop ("# disconnects due to timeout"),
3128                             1,
3129                             GNUNET_NO);
3130   n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
3131   disconnect_neighbour (n, GNUNET_NO);
3132 }
3133
3134
3135 /**
3136  * Schedule the job that will cause us to send a PING to the
3137  * foreign address to evaluate its validity and latency.
3138  *
3139  * @param fal address to PING
3140  */
3141 static void
3142 schedule_next_ping (struct ForeignAddressList *fal);
3143
3144
3145 /**
3146  * Add the given address to the list of foreign addresses
3147  * available for the given peer (check for duplicates).
3148  *
3149  * @param cls the respective 'struct NeighbourList' to update
3150  * @param tname name of the transport
3151  * @param expiration expiration time
3152  * @param addr the address
3153  * @param addrlen length of the address
3154  * @return GNUNET_OK (always)
3155  */
3156 static int
3157 add_to_foreign_address_list (void *cls,
3158                              const char *tname,
3159                              struct GNUNET_TIME_Absolute expiration,
3160                              const void *addr,
3161                              uint16_t addrlen)
3162 {
3163   struct NeighbourList *n = cls;
3164   struct ForeignAddressList *fal;
3165   int try;
3166
3167   GNUNET_STATISTICS_update (stats,
3168                             gettext_noop ("# valid peer addresses returned by PEERINFO"),
3169                             1,
3170                             GNUNET_NO);
3171   try = GNUNET_NO;
3172   fal = find_peer_address (n, tname, NULL, addr, addrlen);
3173   if (fal == NULL)
3174     {
3175 #if DEBUG_TRANSPORT_HELLO
3176       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3177                   "Adding address `%s' (%s) for peer `%4s' due to PEERINFO data for %llums.\n",
3178                   a2s (tname, addr, addrlen),
3179                   tname,
3180                   GNUNET_i2s (&n->id),
3181                   expiration.abs_value);
3182 #endif
3183       fal = add_peer_address (n, tname, NULL, addr, addrlen);
3184       if (fal == NULL)
3185         {
3186           GNUNET_STATISTICS_update (stats,
3187                                     gettext_noop ("# previously validated addresses lacking transport"),
3188                                     1,
3189                                     GNUNET_NO);
3190         }
3191       else
3192         {
3193           fal->expires = GNUNET_TIME_absolute_max (expiration,
3194                                                    fal->expires);
3195           schedule_next_ping (fal);
3196         }
3197       try = GNUNET_YES;
3198     }
3199   else
3200     {
3201       fal->expires = GNUNET_TIME_absolute_max (expiration,
3202                                                fal->expires);
3203     }
3204   if (fal == NULL)
3205     {
3206 #if DEBUG_TRANSPORT
3207       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3208                   "Failed to add new address for `%4s'\n",
3209                   GNUNET_i2s (&n->id));
3210 #endif
3211       return GNUNET_OK;
3212     }
3213   if (fal->validated == GNUNET_NO)
3214     {
3215       fal->validated = GNUNET_YES;
3216       GNUNET_STATISTICS_update (stats,
3217                                 gettext_noop ("# peer addresses considered valid"),
3218                                 1,
3219                                 GNUNET_NO);
3220     }
3221   if (try == GNUNET_YES)
3222     {
3223 #if DEBUG_TRANSPORT
3224       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3225                   "Have new addresses, will try to trigger transmissions.\n");
3226 #endif
3227       try_transmission_to_peer (n);
3228     }
3229   return GNUNET_OK;
3230 }
3231
3232
3233 /**
3234  * Add addresses in validated HELLO "h" to the set of addresses
3235  * we have for this peer.
3236  *
3237  * @param cls closure ('struct NeighbourList*')
3238  * @param peer id of the peer, NULL for last call
3239  * @param h hello message for the peer (can be NULL)
3240  * @param err_msg NULL if successful, otherwise contains error message
3241  */
3242 static void
3243 add_hello_for_peer (void *cls,
3244                     const struct GNUNET_PeerIdentity *peer,
3245                     const struct GNUNET_HELLO_Message *h,
3246                     const char *err_msg)
3247 {
3248   struct NeighbourList *n = cls;
3249
3250   if (err_msg != NULL)
3251     {
3252 #if DEBUG_TRANSPORT
3253       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3254                   _("Error in communication with PEERINFO service: %s\n"),
3255                   err_msg);
3256 #endif
3257       /* return; */
3258     }
3259   if (peer == NULL)
3260     {
3261       GNUNET_STATISTICS_update (stats,
3262                                 gettext_noop ("# outstanding peerinfo iterate requests"),
3263                                 -1,
3264                                 GNUNET_NO);
3265       n->piter = NULL;
3266       return;
3267     }
3268   if (h == NULL)
3269     return; /* no HELLO available */
3270 #if DEBUG_TRANSPORT
3271   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3272               "Peerinfo had `%s' message for peer `%4s', adding existing addresses.\n",
3273               "HELLO",
3274               GNUNET_i2s (peer));
3275 #endif
3276   if (GNUNET_YES != n->public_key_valid)
3277     {
3278       GNUNET_HELLO_get_key (h, &n->publicKey);
3279       n->public_key_valid = GNUNET_YES;
3280     }
3281   GNUNET_HELLO_iterate_addresses (h,
3282                                   GNUNET_NO,
3283                                   &add_to_foreign_address_list,
3284                                   n);
3285 }
3286
3287
3288 /**
3289  * Create a fresh entry in our neighbour list for the given peer.
3290  * Will try to transmit our current HELLO to the new neighbour.
3291  * Do not call this function directly, use 'setup_peer_check_blacklist.
3292  *
3293  * @param peer the peer for which we create the entry
3294  * @param do_hello should we schedule transmitting a HELLO
3295  * @return the new neighbour list entry
3296  */
3297 static struct NeighbourList *
3298 setup_new_neighbour (const struct GNUNET_PeerIdentity *peer,
3299                      int do_hello)
3300 {
3301   struct NeighbourList *n;
3302   struct TransportPlugin *tp;
3303   struct ReadyList *rl;
3304
3305 #if DEBUG_TRANSPORT
3306   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3307               "Setting up state for neighbour `%4s'\n",
3308               GNUNET_i2s (peer));
3309 #endif
3310   GNUNET_assert (our_hello != NULL);
3311   GNUNET_STATISTICS_update (stats,
3312                             gettext_noop ("# active neighbours"),
3313                             1,
3314                             GNUNET_NO);
3315   n = GNUNET_malloc (sizeof (struct NeighbourList));
3316   n->next = neighbours;
3317   neighbours = n;
3318   n->id = *peer;
3319   n->peer_timeout =
3320     GNUNET_TIME_relative_to_absolute
3321     (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
3322   GNUNET_BANDWIDTH_tracker_init (&n->in_tracker,
3323                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
3324                                  MAX_BANDWIDTH_CARRY_S);
3325   tp = plugins;
3326   while (tp != NULL)
3327     {
3328       if ((tp->api->send != NULL) && (!is_blacklisted(peer, tp)))
3329         {
3330           rl = GNUNET_malloc (sizeof (struct ReadyList));
3331           rl->neighbour = n;
3332           rl->next = n->plugins;
3333           n->plugins = rl;
3334           rl->plugin = tp;
3335           rl->addresses = NULL;
3336         }
3337       tp = tp->next;
3338     }
3339   n->latency = GNUNET_TIME_UNIT_FOREVER_REL;
3340   n->distance = -1;
3341   n->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
3342                                                   &neighbour_timeout_task, n);
3343   if (do_hello)
3344     {
3345       GNUNET_STATISTICS_update (stats,
3346                                 gettext_noop ("# peerinfo new neighbor iterate requests"),
3347                                 1,
3348                                 GNUNET_NO);
3349       GNUNET_STATISTICS_update (stats,
3350                                 gettext_noop ("# outstanding peerinfo iterate requests"),
3351                                 1,
3352                                 GNUNET_NO);
3353       n->piter = GNUNET_PEERINFO_iterate (peerinfo, peer,
3354                                           GNUNET_TIME_UNIT_FOREVER_REL,
3355                                           &add_hello_for_peer, n);
3356
3357       GNUNET_STATISTICS_update (stats,
3358                                 gettext_noop ("# HELLO's sent to new neighbors"),
3359                                 1,
3360                                 GNUNET_NO);
3361       transmit_to_peer (NULL, NULL, 0,
3362                         HELLO_ADDRESS_EXPIRATION,
3363                         (const char *) our_hello, GNUNET_HELLO_size(our_hello),
3364                         GNUNET_NO, n);
3365     }
3366   return n;
3367 }
3368
3369
3370 /**
3371  * Function called after we have checked if communicating
3372  * with a given peer is acceptable.
3373  *
3374  * @param cls closure
3375  * @param n NULL if communication is not acceptable
3376  */
3377 typedef void (*SetupContinuation)(void *cls,
3378                                   struct NeighbourList *n);
3379
3380
3381 /**
3382  * Information kept for each client registered to perform
3383  * blacklisting.
3384  */
3385 struct Blacklisters
3386 {
3387   /**
3388    * This is a linked list.
3389    */
3390   struct Blacklisters *next;
3391
3392   /**
3393    * This is a linked list.
3394    */
3395   struct Blacklisters *prev;
3396
3397   /**
3398    * Client responsible for this entry.
3399    */
3400   struct GNUNET_SERVER_Client *client;
3401
3402   /**
3403    * Blacklist check that we're currently performing.
3404    */
3405   struct BlacklistCheck *bc;
3406
3407 };
3408
3409
3410 /**
3411  * Head of DLL of blacklisting clients.
3412  */
3413 static struct Blacklisters *bl_head;
3414
3415 /**
3416  * Tail of DLL of blacklisting clients.
3417  */
3418 static struct Blacklisters *bl_tail;
3419
3420
3421 /**
3422  * Context we use when performing a blacklist check.
3423  */
3424 struct BlacklistCheck
3425 {
3426
3427   /**
3428    * This is a linked list.
3429    */
3430   struct BlacklistCheck *next;
3431
3432   /**
3433    * This is a linked list.
3434    */
3435   struct BlacklistCheck *prev;
3436
3437   /**
3438    * Peer being checked.
3439    */
3440   struct GNUNET_PeerIdentity peer;
3441
3442   /**
3443    * Option for setup neighbour afterwards.
3444    */
3445   int do_hello;
3446
3447   /**
3448    * Continuation to call with the result.
3449    */
3450   SetupContinuation cont;
3451
3452   /**
3453    * Closure for cont.
3454    */
3455   void *cont_cls;
3456
3457   /**
3458    * Current transmission request handle for this client, or NULL if no
3459    * request is pending.
3460    */
3461   struct GNUNET_CONNECTION_TransmitHandle *th;
3462
3463   /**
3464    * Our current position in the blacklisters list.
3465    */
3466   struct Blacklisters *bl_pos;
3467
3468   /**
3469    * Current task performing the check.
3470    */
3471   GNUNET_SCHEDULER_TaskIdentifier task;
3472
3473 };
3474
3475 /**
3476  * Head of DLL of active blacklisting queries.
3477  */
3478 static struct BlacklistCheck *bc_head;
3479
3480 /**
3481  * Tail of DLL of active blacklisting queries.
3482  */
3483 static struct BlacklistCheck *bc_tail;
3484
3485
3486 /**
3487  * Perform next action in the blacklist check.
3488  *
3489  * @param cls the 'struct BlacklistCheck*'
3490  * @param tc unused
3491  */
3492 static void
3493 do_blacklist_check (void *cls,
3494                     const struct GNUNET_SCHEDULER_TaskContext *tc);
3495
3496 /**
3497  * Transmit blacklist query to the client.
3498  *
3499  * @param cls the 'struct BlacklistCheck'
3500  * @param size number of bytes allowed
3501  * @param buf where to copy the message
3502  * @return number of bytes copied to buf
3503  */
3504 static size_t
3505 transmit_blacklist_message (void *cls,
3506                             size_t size,
3507                             void *buf)
3508 {
3509   struct BlacklistCheck *bc = cls;
3510   struct Blacklisters *bl;
3511   struct BlacklistMessage bm;
3512
3513   bc->th = NULL;
3514   if (size == 0)
3515     {
3516       GNUNET_assert (bc->task == GNUNET_SCHEDULER_NO_TASK);
3517       bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
3518                                            bc);
3519       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3520                   "Failed to send blacklist test for peer `%s' to client\n",
3521                   GNUNET_i2s (&bc->peer));
3522       return 0;
3523     }
3524 #if DEBUG_TRANSPORT
3525   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3526               "Sending blacklist test for peer `%s' to client\n",
3527               GNUNET_i2s (&bc->peer));
3528 #endif
3529   bl = bc->bl_pos;
3530   bm.header.size = htons (sizeof (struct BlacklistMessage));
3531   bm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY);
3532   bm.is_allowed = htonl (0);
3533   bm.peer = bc->peer;
3534   memcpy (buf, &bm, sizeof (bm));
3535   GNUNET_SERVER_receive_done (bl->client, GNUNET_OK);
3536   return sizeof (bm);
3537 }
3538
3539
3540 /**
3541  * Perform next action in the blacklist check.
3542  *
3543  * @param cls the 'struct BlacklistCheck*'
3544  * @param tc unused
3545  */
3546 static void
3547 do_blacklist_check (void *cls,
3548                     const struct GNUNET_SCHEDULER_TaskContext *tc)
3549 {
3550   struct BlacklistCheck *bc = cls;
3551   struct Blacklisters *bl;
3552
3553   bc->task = GNUNET_SCHEDULER_NO_TASK;
3554   bl = bc->bl_pos;
3555   if (bl == NULL)
3556     {
3557 #if DEBUG_TRANSPORT
3558       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3559                   "No blacklist clients active, will now setup neighbour record for peer `%s'\n",
3560                   GNUNET_i2s (&bc->peer));
3561 #endif
3562       bc->cont (bc->cont_cls,
3563                 setup_new_neighbour (&bc->peer, bc->do_hello));
3564       GNUNET_free (bc);
3565       return;
3566     }
3567   if (bl->bc == NULL)
3568     {
3569       bl->bc = bc;
3570       bc->th = GNUNET_SERVER_notify_transmit_ready (bl->client,
3571                                                     sizeof (struct BlacklistMessage),
3572                                                     GNUNET_TIME_UNIT_FOREVER_REL,
3573                                                     &transmit_blacklist_message,
3574                                                     bc);
3575     }
3576 }
3577
3578
3579 /**
3580  * Obtain a 'struct NeighbourList' for the given peer.  If such an entry
3581  * does not yet exist, check the blacklist.  If the blacklist says creating
3582  * one is acceptable, create one and call the continuation; otherwise
3583  * call the continuation with NULL.
3584  *
3585  * @param peer peer to setup or look up a struct NeighbourList for
3586  * @param do_hello should we also schedule sending our HELLO to the peer
3587  *        if this is a new record
3588  * @param cont function to call with the 'struct NeigbhbourList*'
3589  * @param cont_cls closure for cont
3590  */
3591 static void
3592 setup_peer_check_blacklist (const struct GNUNET_PeerIdentity *peer,
3593                             int do_hello,
3594                             SetupContinuation cont,
3595                             void *cont_cls)
3596 {
3597   struct NeighbourList *n;
3598   struct BlacklistCheck *bc;
3599
3600   n = find_neighbour(peer);
3601   if (n != NULL)
3602     {
3603 #if DEBUG_TRANSPORT
3604       GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
3605                  "Neighbour record exists for peer `%s'\n",
3606                  GNUNET_i2s(peer));
3607 #endif
3608       if (cont != NULL)
3609         cont (cont_cls, n);
3610       return;
3611     }
3612   if (bl_head == NULL)
3613     {
3614       if (cont != NULL)
3615         cont (cont_cls, setup_new_neighbour (peer, do_hello));
3616       else
3617         setup_new_neighbour(peer, do_hello);
3618       return;
3619     }
3620   bc = GNUNET_malloc (sizeof (struct BlacklistCheck));
3621   GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
3622   bc->peer = *peer;
3623   bc->do_hello = do_hello;
3624   bc->cont = cont;
3625   bc->cont_cls = cont_cls;
3626   bc->bl_pos = bl_head;
3627   bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
3628                                        bc);
3629 }
3630
3631
3632 /**
3633  * Function called with the result of querying a new blacklister about
3634  * it being allowed (or not) to continue to talk to an existing neighbour.
3635  *
3636  * @param cls the original 'struct NeighbourList'
3637  * @param n NULL if we need to disconnect
3638  */
3639 static void
3640 confirm_or_drop_neighbour (void *cls,
3641                            struct NeighbourList *n)
3642 {
3643   struct NeighbourList * orig = cls;
3644
3645   if (n == NULL)
3646     {
3647 #if DEBUG_TRANSPORT
3648       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3649               "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&orig->id),
3650               "confirm_or_drop_neighboUr");
3651 #endif
3652       disconnect_neighbour (orig, GNUNET_NO);
3653     }
3654 }
3655
3656
3657 /**
3658  * Handle a request to start a blacklist.
3659  *
3660  * @param cls closure (always NULL)
3661  * @param client identification of the client
3662  * @param message the actual message
3663  */
3664 static void
3665 handle_blacklist_init (void *cls,
3666                        struct GNUNET_SERVER_Client *client,
3667                        const struct GNUNET_MessageHeader *message)
3668 {
3669   struct Blacklisters *bl;
3670   struct BlacklistCheck *bc;
3671   struct NeighbourList *n;
3672
3673   bl = bl_head;
3674   while (bl != NULL)
3675     {
3676       if (bl->client == client)
3677         {
3678           GNUNET_break (0);
3679           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3680           return;
3681         }
3682       bl = bl->next;
3683     }
3684   bl = GNUNET_malloc (sizeof (struct Blacklisters));
3685   bl->client = client;
3686   GNUNET_SERVER_client_keep (client);
3687   GNUNET_CONTAINER_DLL_insert_after (bl_head, bl_tail, bl_tail, bl);
3688   /* confirm that all existing connections are OK! */
3689   n = neighbours;
3690   while (NULL != n)
3691     {
3692       bc = GNUNET_malloc (sizeof (struct BlacklistCheck));
3693       GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
3694       bc->peer = n->id;
3695       bc->do_hello = GNUNET_NO;
3696       bc->cont = &confirm_or_drop_neighbour;
3697       bc->cont_cls = n;
3698       bc->bl_pos = bl;
3699       if (n == neighbours) /* all would wait for the same client, no need to
3700                               create more than just the first task right now */
3701         bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
3702                                              bc);
3703       n = n->next;
3704     }
3705 }
3706
3707
3708 /**
3709  * Handle a request to blacklist a peer.
3710  *
3711  * @param cls closure (always NULL)
3712  * @param client identification of the client
3713  * @param message the actual message
3714  */
3715 static void
3716 handle_blacklist_reply (void *cls,
3717                         struct GNUNET_SERVER_Client *client,
3718                         const struct GNUNET_MessageHeader *message)
3719 {
3720   const struct BlacklistMessage *msg = (const struct BlacklistMessage*) message;
3721   struct Blacklisters *bl;
3722   struct BlacklistCheck *bc;
3723
3724   bl = bl_head;
3725   while ( (bl != NULL) &&
3726           (bl->client != client) )
3727     bl = bl->next;
3728   if (bl == NULL)
3729     {
3730 #if DEBUG_TRANSPORT
3731       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3732                   "Blacklist client disconnected\n");
3733 #endif
3734       /* FIXME: other error handling here!? */
3735       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
3736       return;
3737     }
3738   bc = bl->bc;
3739   bl->bc = NULL;
3740   if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
3741     {
3742 #if DEBUG_TRANSPORT
3743       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3744                   "Blacklist check failed, peer not allowed\n");
3745 #endif
3746       bc->cont (bc->cont_cls, NULL);
3747       GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
3748       GNUNET_free (bc);
3749     }
3750   else
3751     {
3752 #if DEBUG_TRANSPORT
3753       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3754                   "Blacklist check succeeded, continuing with checks\n");
3755 #endif
3756       bc->bl_pos = bc->bl_pos->next;
3757       bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
3758                                            bc);
3759     }
3760   /* check if any other bc's are waiting for this blacklister */
3761   bc = bc_head;
3762   while (bc != NULL)
3763     {
3764       if ( (bc->bl_pos == bl) &&
3765            (GNUNET_SCHEDULER_NO_TASK == bc->task) )
3766         bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
3767                                              bc);
3768       bc = bc->next;
3769     }
3770 }
3771
3772
3773 /**
3774  * Send periodic PING messages to a given foreign address.
3775  *
3776  * @param cls our 'struct PeriodicValidationContext*'
3777  * @param tc task context
3778  */
3779 static void
3780 send_periodic_ping (void *cls,
3781                     const struct GNUNET_SCHEDULER_TaskContext *tc)
3782 {
3783   struct ForeignAddressList *peer_address = cls;
3784   struct TransportPlugin *tp;
3785   struct ValidationEntry *va;
3786   struct NeighbourList *neighbour;
3787   struct TransportPingMessage ping;
3788   struct CheckAddressExistsClosure caec;
3789   char * message_buf;
3790   uint16_t hello_size;
3791   size_t slen;
3792   size_t tsize;
3793
3794   peer_address->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
3795   if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
3796     return;
3797   tp = peer_address->ready_list->plugin;
3798   neighbour = peer_address->ready_list->neighbour;
3799   if (GNUNET_YES != neighbour->public_key_valid)
3800     {
3801       /* no public key yet, try again later */
3802       schedule_next_ping (peer_address);
3803       return;
3804     }
3805   caec.addr = peer_address->addr;
3806   caec.addrlen = peer_address->addrlen;
3807   caec.tname = tp->short_name;
3808   caec.session = peer_address->session;
3809   caec.exists = GNUNET_NO;
3810   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
3811                                          &check_address_exists,
3812                                          &caec);
3813   if (caec.exists == GNUNET_YES)
3814     {
3815       /* During validation attempts we will likely trigger the other
3816          peer trying to validate our address which in turn will cause
3817          it to send us its HELLO, so we expect to hit this case rather
3818          frequently.  Only print something if we are very verbose. */
3819 #if DEBUG_TRANSPORT > 1
3820       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3821                   "Some validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
3822                   (peer_address->addr != NULL)
3823                   ? a2s (tp->short_name,
3824                          peer_address->addr,
3825                          peer_address->addrlen)
3826                   : "<inbound>",
3827                   tp->short_name,
3828                   GNUNET_i2s (&neighbour->id));
3829 #endif
3830       schedule_next_ping (peer_address);
3831       return;
3832     }
3833   va = GNUNET_malloc (sizeof (struct ValidationEntry) + peer_address->addrlen);
3834   va->transport_name = GNUNET_strdup (tp->short_name);
3835   va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
3836                                             UINT_MAX);
3837   va->send_time = GNUNET_TIME_absolute_get();
3838   va->session = peer_address->session;
3839   if (peer_address->addr != NULL)
3840     {
3841       va->addr = (const void*) &va[1];
3842       memcpy (&va[1], peer_address->addr, peer_address->addrlen);
3843       va->addrlen = peer_address->addrlen;
3844     }
3845   memcpy(&va->publicKey,
3846          &neighbour->publicKey,
3847          sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
3848
3849   va->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
3850                                                    &timeout_hello_validation,
3851                                                    va);
3852   GNUNET_CONTAINER_multihashmap_put (validation_map,
3853                                      &neighbour->id.hashPubKey,
3854                                      va,
3855                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
3856
3857   if (peer_address->validated != GNUNET_YES)
3858     hello_size = GNUNET_HELLO_size(our_hello);
3859   else
3860     hello_size = 0;
3861
3862   tsize = sizeof(struct TransportPingMessage) + hello_size;
3863
3864   if (peer_address->addr != NULL)
3865     {
3866       slen = strlen (tp->short_name) + 1;
3867       tsize += slen + peer_address->addrlen;
3868     }
3869   else
3870     {
3871       slen = 0; /* make gcc happy */
3872     }
3873   message_buf = GNUNET_malloc(tsize);
3874   ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
3875   ping.challenge = htonl(va->challenge);
3876   memcpy(&ping.target, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
3877   if (peer_address->validated != GNUNET_YES)
3878     {
3879       memcpy(message_buf, our_hello, hello_size);
3880     }
3881
3882   if (peer_address->addr != NULL)
3883     {
3884       ping.header.size = htons(sizeof(struct TransportPingMessage) +
3885                                peer_address->addrlen +
3886                                slen);
3887       memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage)],
3888              tp->short_name,
3889              slen);
3890       memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage) + slen],
3891              peer_address->addr,
3892              peer_address->addrlen);
3893     }
3894   else
3895     {
3896       ping.header.size = htons(sizeof(struct TransportPingMessage));
3897     }
3898
3899   memcpy(&message_buf[hello_size],
3900          &ping,
3901          sizeof(struct TransportPingMessage));
3902
3903 #if DEBUG_TRANSPORT_REVALIDATION
3904   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3905               "Performing re-validation of address `%s' via `%s' for peer `%4s' sending `%s' (%u bytes) and `%s'\n",
3906               (peer_address->addr != NULL)
3907               ? a2s (peer_address->plugin->short_name,
3908                      peer_address->addr,
3909                      peer_address->addrlen)
3910               : "<inbound>",
3911               tp->short_name,
3912               GNUNET_i2s (&neighbour->id),
3913               "HELLO", hello_size,
3914               "PING");
3915 #endif
3916   if (peer_address->validated != GNUNET_YES)
3917     GNUNET_STATISTICS_update (stats,
3918                               gettext_noop ("# PING with HELLO messages sent"),
3919                               1,
3920                               GNUNET_NO);
3921   else
3922     GNUNET_STATISTICS_update (stats,
3923                               gettext_noop ("# PING without HELLO messages sent"),
3924                               1,
3925                               GNUNET_NO);
3926   GNUNET_STATISTICS_update (stats,
3927                             gettext_noop ("# PING messages sent for re-validation"),
3928                             1,
3929                             GNUNET_NO);
3930   transmit_to_peer (NULL, peer_address,
3931                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
3932                     HELLO_VERIFICATION_TIMEOUT,
3933                     message_buf, tsize,
3934                     GNUNET_YES, neighbour);
3935   GNUNET_free(message_buf);
3936   schedule_next_ping (peer_address);
3937 }
3938
3939
3940 /**
3941  * Schedule the job that will cause us to send a PING to the
3942  * foreign address to evaluate its validity and latency.
3943  *
3944  * @param fal address to PING
3945  */
3946 static void
3947 schedule_next_ping (struct ForeignAddressList *fal)
3948 {
3949   struct GNUNET_TIME_Relative delay;
3950
3951   if (fal->revalidate_task != GNUNET_SCHEDULER_NO_TASK)
3952     return;
3953   delay = GNUNET_TIME_absolute_get_remaining (fal->expires);
3954   delay.rel_value /= 2; /* do before expiration */
3955   delay = GNUNET_TIME_relative_min (delay,
3956                                     LATENCY_EVALUATION_MAX_DELAY);
3957   if (GNUNET_YES != fal->estimated)
3958     {
3959       delay = GNUNET_TIME_UNIT_ZERO;
3960       fal->estimated = GNUNET_YES;
3961     }
3962   if (GNUNET_YES == fal->connected)
3963     {
3964       delay = GNUNET_TIME_relative_min (delay,
3965                                         CONNECTED_LATENCY_EVALUATION_MAX_DELAY);
3966     }
3967   /* FIXME: also adjust delay based on how close the last
3968      observed latency is to the latency of the best alternative */
3969   /* bound how fast we can go */
3970   delay = GNUNET_TIME_relative_max (delay,
3971                                     GNUNET_TIME_UNIT_SECONDS);
3972   /* randomize a bit (to avoid doing all at the same time) */
3973   delay.rel_value += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
3974   fal->revalidate_task = GNUNET_SCHEDULER_add_delayed(delay,
3975                                                       &send_periodic_ping,
3976                                                       fal);
3977 }
3978
3979
3980
3981
3982 /**
3983  * Function that will be called if we receive some payload
3984  * from another peer.
3985  *
3986  * @param message the payload
3987  * @param n peer who claimed to be the sender
3988  */
3989 static void
3990 handle_payload_message (const struct GNUNET_MessageHeader *message,
3991                                                 struct NeighbourList *n)
3992 {
3993   struct InboundMessage *im;
3994   struct TransportClient *cpos;
3995   uint16_t msize;
3996
3997   msize = ntohs (message->size);
3998   if (n->received_pong == GNUNET_NO)
3999     {
4000 #if DEBUG_TRANSPORT
4001       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4002                   "Received message of type %u and size %u from `%4s', but no pong yet!!\n",
4003                   ntohs (message->type),
4004                   ntohs (message->size),
4005                   GNUNET_i2s (&n->id));
4006 #endif
4007       GNUNET_free_non_null (n->pre_connect_message_buffer);
4008       n->pre_connect_message_buffer = GNUNET_malloc (msize);
4009       memcpy (n->pre_connect_message_buffer, message, msize);
4010       return;
4011     }
4012
4013 #if DEBUG_TRANSPORT
4014   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4015               "Received message of type %u and size %u from `%4s', sending to all clients.\n",
4016               ntohs (message->type),
4017               ntohs (message->size),
4018               GNUNET_i2s (&n->id));
4019 #endif
4020   if (GNUNET_YES == GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
4021                                                       (ssize_t) msize))
4022     {
4023       n->quota_violation_count++;
4024 #if DEBUG_TRANSPORT
4025       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4026                   "Bandwidth quota (%u b/s) violation detected (total of %u).\n",
4027                   n->in_tracker.available_bytes_per_s__,
4028                   n->quota_violation_count);
4029 #endif
4030       /* Discount 32k per violation */
4031       GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
4032                                         - 32 * 1024);
4033     }
4034   else
4035     {
4036       if (n->quota_violation_count > 0)
4037         {
4038           /* try to add 32k back */
4039           GNUNET_BANDWIDTH_tracker_consume (&n->in_tracker,
4040                                             32 * 1024);
4041           n->quota_violation_count--;
4042         }
4043     }
4044   GNUNET_STATISTICS_update (stats,
4045                             gettext_noop ("# payload received from other peers"),
4046                             msize,
4047                             GNUNET_NO);
4048   /* transmit message to all clients */
4049   uint32_t ats_count = 2;
4050   size_t size = sizeof (struct InboundMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information) + msize;
4051   if (size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
4052           GNUNET_break(0);
4053
4054   im = GNUNET_malloc (size);
4055   im->header.size = htons (size);
4056   im->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
4057   im->peer = n->id;
4058   im->ats_count = htonl(ats_count);
4059   /* Setting ATS data */
4060   (&(im->ats))[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
4061   (&(im->ats))[0].value = htonl (n->distance);
4062   (&(im->ats))[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
4063   (&(im->ats))[1].value = htonl ((uint32_t) n->latency.rel_value);
4064   (&(im->ats))[ats_count].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
4065   (&(im->ats))[ats_count].value = htonl (0);
4066
4067   memcpy (&((&(im->ats))[ats_count+1]), message, msize);
4068   cpos = clients;
4069   while (cpos != NULL)
4070     {
4071       transmit_to_client (cpos, &im->header, GNUNET_YES);
4072       cpos = cpos->next;
4073     }
4074   GNUNET_free (im);
4075 }
4076
4077
4078 /**
4079  * Iterator over hash map entries.  Checks if the given validation
4080  * entry is for the same challenge as what is given in the PONG.
4081  *
4082  * @param cls the 'struct TransportPongMessage*'
4083  * @param key peer identity
4084  * @param value value in the hash map ('struct ValidationEntry')
4085  * @return GNUNET_YES if we should continue to
4086  *         iterate (mismatch), GNUNET_NO if not (entry matched)
4087  */
4088 static int
4089 check_pending_validation (void *cls,
4090                           const GNUNET_HashCode * key,
4091                           void *value)
4092 {
4093   const struct TransportPongMessage *pong = cls;
4094   struct ValidationEntry *ve = value;
4095   struct AddValidatedAddressContext avac;
4096   unsigned int challenge = ntohl(pong->challenge);
4097   struct GNUNET_HELLO_Message *hello;
4098   struct GNUNET_PeerIdentity target;
4099   struct NeighbourList *n;
4100   struct ForeignAddressList *fal;
4101   struct OwnAddressList *oal;
4102   struct TransportPlugin *tp;
4103   struct GNUNET_MessageHeader *prem;
4104   uint16_t ps;
4105   const char *addr;
4106   size_t slen;
4107   size_t alen;
4108
4109   ps = ntohs (pong->header.size);
4110   if (ps < sizeof (struct TransportPongMessage))
4111     {
4112       GNUNET_break_op (0);
4113       return GNUNET_NO;
4114     }
4115   addr = (const char*) &pong[1];
4116   slen = strlen (ve->transport_name) + 1;
4117   if ( (ps - sizeof (struct TransportPongMessage) < slen) ||
4118        (ve->challenge != challenge) ||
4119        (addr[slen-1] != '\0') ||
4120        (0 != strcmp (addr, ve->transport_name)) ||
4121        (ntohl (pong->purpose.size)
4122         != sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
4123         sizeof (uint32_t) +
4124         sizeof (struct GNUNET_TIME_AbsoluteNBO) +
4125         sizeof (struct GNUNET_PeerIdentity) + ps - sizeof (struct TransportPongMessage)) )
4126     {
4127       return GNUNET_YES;
4128     }
4129
4130   alen = ps - sizeof (struct TransportPongMessage) - slen;
4131   switch (ntohl (pong->purpose.purpose))
4132     {
4133     case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN:
4134       if ( (ve->addrlen + slen != ntohl (pong->addrlen)) ||
4135            (0 != memcmp (&addr[slen],
4136                          ve->addr,
4137                          ve->addrlen)) )
4138         {
4139           return GNUNET_YES; /* different entry, keep trying! */
4140         }
4141       if (0 != memcmp (&pong->pid,
4142                        key,
4143                        sizeof (struct GNUNET_PeerIdentity)))
4144         {
4145           GNUNET_break_op (0);
4146           return GNUNET_NO;
4147         }
4148       if (GNUNET_OK !=
4149           GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN,
4150                                     &pong->purpose,
4151                                     &pong->signature,
4152                                     &ve->publicKey))
4153         {
4154           GNUNET_break_op (0);
4155           return GNUNET_NO;
4156         }
4157
4158 #if DEBUG_TRANSPORT
4159       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4160                   "Confirmed validity of address, peer `%4s' has address `%s' (%s).\n",
4161                   GNUNET_h2s (key),
4162                   a2s (ve->transport_name,
4163                        (const struct sockaddr *) ve->addr,
4164                        ve->addrlen),
4165                   ve->transport_name);
4166 #endif
4167       break;
4168     case GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING:
4169       if (0 != memcmp (&pong->pid,
4170                          &my_identity,
4171                          sizeof (struct GNUNET_PeerIdentity)))
4172         {
4173       char * peer;
4174           GNUNET_asprintf(&peer, "%s",GNUNET_i2s (&pong->pid));
4175 #if DEBUG_TRANSPORT
4176           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4177                       "Received PONG for different identity: I am `%s', PONG identity: `%s'\n",
4178                       GNUNET_i2s (&my_identity),
4179                       peer );
4180 #endif
4181           GNUNET_free (peer);
4182           return GNUNET_NO;
4183         }
4184       if (ve->addrlen != 0)
4185         {
4186           /* must have been for a different validation entry */
4187           return GNUNET_YES;
4188         }
4189       tp = find_transport (ve->transport_name);
4190       if (tp == NULL)
4191         {
4192           GNUNET_break (0);
4193           return GNUNET_YES;
4194         }
4195       oal = tp->addresses;
4196       while (NULL != oal)
4197         {
4198           if ( (oal->addrlen == alen) &&
4199                (0 == memcmp (&oal[1],
4200                              &addr[slen],
4201                              alen)) )
4202             break;
4203           oal = oal->next;
4204         }
4205       if (oal == NULL)
4206         {
4207           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
4208                       _("Not accepting PONG with address `%s' since I cannot confirm having this address.\n"),
4209                       a2s (ve->transport_name,
4210                            &addr[slen],
4211                            alen));
4212           return GNUNET_NO;
4213         }
4214       if (GNUNET_OK !=
4215           GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING,
4216                                     &pong->purpose,
4217                                     &pong->signature,
4218                                     &ve->publicKey))
4219         {
4220           GNUNET_break_op (0);
4221           return GNUNET_NO;
4222         }
4223
4224 #if DEBUG_TRANSPORT
4225       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4226                   "Confirmed that peer `%4s' is talking to us using address `%s' (%s) for us.\n",
4227                   GNUNET_h2s (key),
4228                   a2s (ve->transport_name,
4229                        &addr[slen],
4230                        alen),
4231                   ve->transport_name);
4232 #endif
4233       break;
4234     default:
4235       GNUNET_break_op (0);
4236       return GNUNET_NO;
4237     }
4238   if (GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_ntoh (pong->expiration)).rel_value == 0)
4239     {
4240       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
4241                   _("Received expired signature.  Check system time.\n"));
4242       return GNUNET_NO;
4243     }
4244   GNUNET_STATISTICS_update (stats,
4245                             gettext_noop ("# address validation successes"),
4246                             1,
4247                             GNUNET_NO);
4248   /* create the updated HELLO */
4249   GNUNET_CRYPTO_hash (&ve->publicKey,
4250                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4251                       &target.hashPubKey);
4252   if (ve->addr != NULL)
4253     {
4254       avac.done = GNUNET_NO;
4255       avac.ve = ve;
4256       hello = GNUNET_HELLO_create (&ve->publicKey,
4257                                    &add_validated_address,
4258                                    &avac);
4259       GNUNET_PEERINFO_add_peer (peerinfo,
4260                                 hello);
4261       GNUNET_free (hello);
4262     }
4263   n = find_neighbour (&target);
4264   if (n != NULL)
4265     {
4266       n->publicKey = ve->publicKey;
4267       n->public_key_valid = GNUNET_YES;
4268       fal = add_peer_address (n,
4269                               ve->transport_name,
4270                               ve->session,
4271                               ve->addr,
4272                               ve->addrlen);
4273       GNUNET_assert (fal != NULL);
4274       fal->expires = GNUNET_TIME_relative_to_absolute (HELLO_ADDRESS_EXPIRATION);
4275       fal->validated = GNUNET_YES;
4276       mark_address_connected (fal);
4277       GNUNET_STATISTICS_update (stats,
4278                                 gettext_noop ("# peer addresses considered valid"),
4279                                 1,
4280                                 GNUNET_NO);
4281       fal->latency = GNUNET_TIME_absolute_get_duration (ve->send_time);
4282       update_addr_value (fal, GNUNET_TIME_absolute_get_duration (ve->send_time).rel_value, GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
4283
4284       schedule_next_ping (fal);
4285       if (n->latency.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
4286         n->latency = fal->latency;
4287       else
4288         n->latency.rel_value = (fal->latency.rel_value + n->latency.rel_value) / 2;
4289
4290       n->distance = fal->distance;
4291       if (GNUNET_NO == n->received_pong)
4292         {
4293           n->received_pong = GNUNET_YES;
4294
4295           notify_clients_connect (&target, n->latency, n->distance);
4296           if (NULL != (prem = n->pre_connect_message_buffer))
4297             {
4298               n->pre_connect_message_buffer = NULL;
4299               handle_payload_message (prem, n);
4300               GNUNET_free (prem);
4301             }
4302         }
4303       if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
4304         {
4305           GNUNET_SCHEDULER_cancel (n->retry_task);
4306           n->retry_task = GNUNET_SCHEDULER_NO_TASK;
4307           try_transmission_to_peer (n);
4308         }
4309     }
4310
4311   /* clean up validation entry */
4312   GNUNET_assert (GNUNET_YES ==
4313                  GNUNET_CONTAINER_multihashmap_remove (validation_map,
4314                                                        key,
4315                                                        ve));
4316   abort_validation (NULL, NULL, ve);
4317   return GNUNET_NO;
4318 }
4319
4320
4321 /**
4322  * Function that will be called if we receive a validation
4323  * of an address challenge that we transmitted to another
4324  * peer.  Note that the validation should only be considered
4325  * acceptable if the challenge matches AND if the sender
4326  * address is at least a plausible address for this peer
4327  * (otherwise we may be seeing a MiM attack).
4328  *
4329  * @param cls closure
4330  * @param message the pong message
4331  * @param peer who responded to our challenge
4332  * @param sender_address string describing our sender address (as observed
4333  *         by the other peer in binary format)
4334  * @param sender_address_len number of bytes in 'sender_address'
4335  */
4336 static void
4337 handle_pong (void *cls, const struct GNUNET_MessageHeader *message,
4338              const struct GNUNET_PeerIdentity *peer,
4339              const char *sender_address,
4340              size_t sender_address_len)
4341 {
4342 #if DEBUG_TRANSPORT > 1
4343   /* we get tons of these that just get discarded, only log
4344      if we are quite verbose */
4345   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4346               "Receiving `%s' message from `%4s'.\n", "PONG",
4347               GNUNET_i2s (peer));
4348 #endif
4349   GNUNET_STATISTICS_update (stats,
4350                             gettext_noop ("# PONG messages received"),
4351                             1,
4352                             GNUNET_NO);
4353   if (GNUNET_SYSERR !=
4354       GNUNET_CONTAINER_multihashmap_get_multiple (validation_map,
4355                                                   &peer->hashPubKey,
4356                                                   &check_pending_validation,
4357                                                   (void*) message))
4358     {
4359       /* This is *expected* to happen a lot since we send
4360          PONGs to *all* known addresses of the sender of
4361          the PING, so most likely we get multiple PONGs
4362          per PING, and all but the first PONG will end up
4363          here. So really we should not print anything here
4364          unless we want to be very, very verbose... */
4365 #if DEBUG_TRANSPORT > 2
4366       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4367                   "Received `%s' message from `%4s' but have no record of a matching `%s' message. Ignoring.\n",
4368                   "PONG",
4369                   GNUNET_i2s (peer),
4370                   "PING");
4371 #endif
4372       return;
4373     }
4374
4375 }
4376
4377
4378 /**
4379  * Try to validate a neighbour's address by sending him our HELLO and a PING.
4380  *
4381  * @param cls the 'struct ValidationEntry*'
4382  * @param neighbour neighbour to validate, NULL if validation failed
4383  */
4384 static void
4385 transmit_hello_and_ping (void *cls,
4386                          struct NeighbourList *neighbour)
4387 {
4388   struct ValidationEntry *va = cls;
4389   struct ForeignAddressList *peer_address;
4390   struct TransportPingMessage ping;
4391   uint16_t hello_size;
4392   size_t tsize;
4393   char * message_buf;
4394   struct GNUNET_PeerIdentity id;
4395   size_t slen;
4396
4397   GNUNET_CRYPTO_hash (&va->publicKey,
4398                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4399                       &id.hashPubKey);
4400   if (neighbour == NULL)
4401     {
4402       /* FIXME: stats... */
4403       GNUNET_break (GNUNET_OK ==
4404                     GNUNET_CONTAINER_multihashmap_remove (validation_map,
4405                                                           &id.hashPubKey,
4406                                                           va));
4407       abort_validation (NULL, NULL, va);
4408       return;
4409     }
4410   neighbour->publicKey = va->publicKey;
4411   neighbour->public_key_valid = GNUNET_YES;
4412   peer_address = add_peer_address (neighbour,
4413                                    va->transport_name, NULL,
4414                                    (const void*) &va[1],
4415                                    va->addrlen);
4416   if (peer_address == NULL)
4417     {
4418       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
4419                   "Failed to add peer `%4s' for plugin `%s'\n",
4420                   GNUNET_i2s (&neighbour->id),
4421                   va->transport_name);
4422       GNUNET_break (GNUNET_OK ==
4423                     GNUNET_CONTAINER_multihashmap_remove (validation_map,
4424                                                           &id.hashPubKey,
4425                                                           va));
4426       abort_validation (NULL, NULL, va);
4427       return;
4428     }
4429   hello_size = GNUNET_HELLO_size(our_hello);
4430   slen = strlen(va->transport_name) + 1;
4431   tsize = sizeof(struct TransportPingMessage) + hello_size + va->addrlen + slen;
4432   message_buf = GNUNET_malloc(tsize);
4433   ping.challenge = htonl(va->challenge);
4434   ping.header.size = htons(sizeof(struct TransportPingMessage) + slen + va->addrlen);
4435   ping.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_PING);
4436   memcpy(&ping.target, &neighbour->id, sizeof(struct GNUNET_PeerIdentity));
4437   memcpy(message_buf, our_hello, hello_size);
4438   memcpy(&message_buf[hello_size],
4439          &ping,
4440          sizeof(struct TransportPingMessage));
4441   memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage)],
4442          va->transport_name,
4443          slen);
4444   memcpy(&message_buf[hello_size + sizeof (struct TransportPingMessage) + slen],
4445          &va[1],
4446          va->addrlen);
4447 #if DEBUG_TRANSPORT
4448   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4449               "Performing validation of address `%s' via `%s' for peer `%4s' sending `%s' (%u bytes) and `%s' (%u bytes)\n",
4450               (va->addrlen == 0)
4451               ? "<inbound>"
4452               : a2s (va->transport_name,
4453                      (const void*) &va[1], va->addrlen),
4454               va->transport_name,
4455               GNUNET_i2s (&neighbour->id),
4456               "HELLO", hello_size,
4457               "PING", sizeof (struct TransportPingMessage) + va->addrlen + slen);
4458 #endif
4459
4460   GNUNET_STATISTICS_update (stats,
4461                             gettext_noop ("# PING messages sent for initial validation"),
4462                             1,
4463                             GNUNET_NO);
4464   transmit_to_peer (NULL, peer_address,
4465                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
4466                     HELLO_VERIFICATION_TIMEOUT,
4467                     message_buf, tsize,
4468                     GNUNET_YES, neighbour);
4469   GNUNET_free(message_buf);
4470 }
4471
4472
4473 /**
4474  * Check if the given address is already being validated; if not,
4475  * append the given address to the list of entries that are being be
4476  * validated and initiate validation.
4477  *
4478  * @param cls closure ('struct CheckHelloValidatedContext *')
4479  * @param tname name of the transport
4480  * @param expiration expiration time
4481  * @param addr the address
4482  * @param addrlen length of the address
4483  * @return GNUNET_OK (always)
4484  */
4485 static int
4486 run_validation (void *cls,
4487                 const char *tname,
4488                 struct GNUNET_TIME_Absolute expiration,
4489                 const void *addr,
4490                 uint16_t addrlen)
4491 {
4492   struct CheckHelloValidatedContext *chvc = cls;
4493   struct GNUNET_PeerIdentity id;
4494   struct TransportPlugin *tp;
4495   struct ValidationEntry *va;
4496   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk;
4497   struct CheckAddressExistsClosure caec;
4498   struct OwnAddressList *oal;
4499
4500   GNUNET_assert (addr != NULL);
4501
4502   GNUNET_STATISTICS_update (stats,
4503                             gettext_noop ("# peer addresses scheduled for validation"),
4504                             1,
4505                             GNUNET_NO);
4506   tp = find_transport (tname);
4507   if (tp == NULL)
4508     {
4509       GNUNET_log (GNUNET_ERROR_TYPE_INFO |
4510                   GNUNET_ERROR_TYPE_BULK,
4511                   _
4512                   ("Transport `%s' not loaded, will not try to validate peer address using this transport.\n"),
4513                   tname);
4514       GNUNET_STATISTICS_update (stats,
4515                                 gettext_noop ("# peer addresses not validated (plugin not available)"),
4516                                 1,
4517                                 GNUNET_NO);
4518       return GNUNET_OK;
4519     }
4520   /* check if this is one of our own addresses */
4521   oal = tp->addresses;
4522   while (NULL != oal)
4523     {
4524       if ( (oal->addrlen == addrlen) &&
4525            (0 == memcmp (&oal[1],
4526                          addr,
4527                          addrlen)) )
4528         {
4529           /* not plausible, this address is equivalent to our own address! */
4530           GNUNET_STATISTICS_update (stats,
4531                                     gettext_noop ("# peer addresses not validated (loopback)"),
4532                                     1,
4533                                     GNUNET_NO);
4534           return GNUNET_OK;
4535         }
4536       oal = oal->next;
4537     }
4538   GNUNET_HELLO_get_key (chvc->hello, &pk);
4539   GNUNET_CRYPTO_hash (&pk,
4540                       sizeof (struct
4541                               GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4542                       &id.hashPubKey);
4543
4544   if (is_blacklisted(&id, tp))
4545     {
4546 #if DEBUG_TRANSPORT
4547       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4548                   "Attempted to validate blacklisted peer `%s' using `%s'!\n",
4549                   GNUNET_i2s(&id),
4550                   tname);
4551 #endif
4552       return GNUNET_OK;
4553     }
4554
4555   caec.addr = addr;
4556   caec.addrlen = addrlen;
4557   caec.session = NULL;
4558   caec.tname = tname;
4559   caec.exists = GNUNET_NO;
4560   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
4561                                          &check_address_exists,
4562                                          &caec);
4563   if (caec.exists == GNUNET_YES)
4564     {
4565       /* During validation attempts we will likely trigger the other
4566          peer trying to validate our address which in turn will cause
4567          it to send us its HELLO, so we expect to hit this case rather
4568          frequently.  Only print something if we are very verbose. */
4569 #if DEBUG_TRANSPORT > 1
4570       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4571                   "Validation of address `%s' via `%s' for peer `%4s' already in progress.\n",
4572                   a2s (tname, addr, addrlen),
4573                   tname,
4574                   GNUNET_i2s (&id));
4575 #endif
4576       GNUNET_STATISTICS_update (stats,
4577                                 gettext_noop ("# peer addresses not validated (in progress)"),
4578                                 1,
4579                                 GNUNET_NO);
4580       return GNUNET_OK;
4581     }
4582   va = GNUNET_malloc (sizeof (struct ValidationEntry) + addrlen);
4583   va->chvc = chvc;
4584   chvc->ve_count++;
4585   va->transport_name = GNUNET_strdup (tname);
4586   va->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
4587                                             UINT_MAX);
4588   va->send_time = GNUNET_TIME_absolute_get();
4589   va->addr = (const void*) &va[1];
4590   memcpy (&va[1], addr, addrlen);
4591   va->addrlen = addrlen;
4592   GNUNET_HELLO_get_key (chvc->hello,
4593                         &va->publicKey);
4594   va->timeout_task = GNUNET_SCHEDULER_add_delayed (HELLO_VERIFICATION_TIMEOUT,
4595                                                    &timeout_hello_validation,
4596                                                    va);
4597   GNUNET_CONTAINER_multihashmap_put (validation_map,
4598                                      &id.hashPubKey,
4599                                      va,
4600                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
4601   setup_peer_check_blacklist (&id, GNUNET_NO,
4602                               &transmit_hello_and_ping,
4603                               va);
4604   return GNUNET_OK;
4605 }
4606
4607
4608 /**
4609  * Check if addresses in validated hello "h" overlap with
4610  * those in "chvc->hello" and validate the rest.
4611  *
4612  * @param cls closure
4613  * @param peer id of the peer, NULL for last call
4614  * @param h hello message for the peer (can be NULL)
4615  * @param err_msg NULL if successful, otherwise contains error message
4616  */
4617 static void
4618 check_hello_validated (void *cls,
4619                        const struct GNUNET_PeerIdentity *peer,
4620                        const struct GNUNET_HELLO_Message *h,
4621                        const char *err_msg)
4622 {
4623   struct CheckHelloValidatedContext *chvc = cls;
4624   struct GNUNET_HELLO_Message *plain_hello;
4625   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk;
4626   struct GNUNET_PeerIdentity target;
4627   struct NeighbourList *n;
4628
4629   if (err_msg != NULL)
4630     {
4631 #if DEBUG_TRANSPORT
4632       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4633                   _("Error in communication with PEERINFO service: %s\n"),
4634                   err_msg);
4635 #endif
4636       /* return; */
4637   }
4638
4639   if (peer == NULL)
4640     {
4641       GNUNET_STATISTICS_update (stats,
4642                                 gettext_noop ("# outstanding peerinfo iterate requests"),
4643                                 -1,
4644                                 GNUNET_NO);
4645       chvc->piter = NULL;
4646       if (GNUNET_NO == chvc->hello_known)
4647         {
4648           /* notify PEERINFO about the peer now, so that we at least
4649              have the public key if some other component needs it */
4650           GNUNET_HELLO_get_key (chvc->hello, &pk);
4651           GNUNET_CRYPTO_hash (&pk,
4652                               sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4653                               &target.hashPubKey);
4654           plain_hello = GNUNET_HELLO_create (&pk,
4655                                              NULL,
4656                                              NULL);
4657           GNUNET_PEERINFO_add_peer (peerinfo, plain_hello);
4658           GNUNET_free (plain_hello);
4659 #if DEBUG_TRANSPORT_HELLO
4660           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4661                       "PEERINFO had no `%s' message for peer `%4s', full validation needed.\n",
4662                       "HELLO",
4663                       GNUNET_i2s (&target));
4664 #endif
4665           GNUNET_STATISTICS_update (stats,
4666                                     gettext_noop ("# new HELLOs requiring full validation"),
4667                                     1,
4668                                     GNUNET_NO);
4669           GNUNET_HELLO_iterate_addresses (chvc->hello,
4670                                           GNUNET_NO,
4671                                           &run_validation,
4672                                           chvc);
4673         }
4674       else
4675         {
4676           GNUNET_STATISTICS_update (stats,
4677                                     gettext_noop ("# duplicate HELLO (peer known)"),
4678                                     1,
4679                                     GNUNET_NO);
4680         }
4681       chvc->ve_count--;
4682       if (chvc->ve_count == 0)
4683         {
4684           GNUNET_CONTAINER_DLL_remove (chvc_head,
4685                                        chvc_tail,
4686                                        chvc);
4687           GNUNET_free (chvc);
4688         }
4689       return;
4690     }
4691   if (h == NULL)
4692     return;
4693 #if DEBUG_TRANSPORT_HELLO
4694   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4695               "PEERINFO had `%s' message for peer `%4s', validating only new addresses.\n",
4696               "HELLO",
4697               GNUNET_i2s (peer));
4698 #endif
4699   chvc->hello_known = GNUNET_YES;
4700   n = find_neighbour (peer);
4701   if (n != NULL)
4702     {
4703 #if DEBUG_TRANSPORT_HELLO
4704       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4705                   "Calling hello_iterate_addresses for %s!\n",
4706                   GNUNET_i2s (peer));
4707 #endif
4708       GNUNET_HELLO_iterate_addresses (h,
4709                                       GNUNET_NO,
4710                                       &add_to_foreign_address_list,
4711                                       n);
4712       try_transmission_to_peer (n);
4713     }
4714   else
4715     {
4716 #if DEBUG_TRANSPORT_HELLO
4717       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4718                   "No existing neighbor record for %s!\n",
4719                   GNUNET_i2s (peer));
4720 #endif
4721       GNUNET_STATISTICS_update (stats,
4722                                 gettext_noop ("# no existing neighbour record (validating HELLO)"),
4723                                 1,
4724                                 GNUNET_NO);
4725     }
4726   GNUNET_STATISTICS_update (stats,
4727                             gettext_noop ("# HELLO validations (update case)"),
4728                             1,
4729                             GNUNET_NO);
4730   GNUNET_HELLO_iterate_new_addresses (chvc->hello,
4731                                       h,
4732                                       GNUNET_TIME_relative_to_absolute (HELLO_REVALIDATION_START_TIME),
4733                                       &run_validation,
4734                                       chvc);
4735 }
4736
4737
4738 /**
4739  * Process HELLO-message.
4740  *
4741  * @param plugin transport involved, may be NULL
4742  * @param message the actual message
4743  * @return GNUNET_OK if the HELLO was well-formed, GNUNET_SYSERR otherwise
4744  */
4745 static int
4746 process_hello (struct TransportPlugin *plugin,
4747                const struct GNUNET_MessageHeader *message)
4748 {
4749   uint16_t hsize;
4750   struct GNUNET_PeerIdentity target;
4751   const struct GNUNET_HELLO_Message *hello;
4752   struct CheckHelloValidatedContext *chvc;
4753   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded publicKey;
4754 #if DEBUG_TRANSPORT_HELLO > 2
4755   char *my_id;
4756 #endif
4757   hsize = ntohs (message->size);
4758   if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_HELLO) ||
4759       (hsize < sizeof (struct GNUNET_MessageHeader)))
4760     {
4761       GNUNET_break (0);
4762       return GNUNET_SYSERR;
4763     }
4764   GNUNET_STATISTICS_update (stats,
4765                             gettext_noop ("# HELLOs received for validation"),
4766                             1,
4767                             GNUNET_NO);
4768
4769   /* first, check if load is too high */
4770   if (GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_BACKGROUND) > MAX_HELLO_LOAD)
4771     {
4772       GNUNET_STATISTICS_update (stats,
4773                                 gettext_noop ("# HELLOs ignored due to high load"),
4774                                 1,
4775                                 GNUNET_NO);
4776 #if DEBUG_TRANSPORT_HELLO
4777       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4778                   "Ignoring `%s' for `%4s', load too high.\n",
4779                   "HELLO",
4780                   GNUNET_i2s (&target));
4781 #endif
4782       return GNUNET_OK;
4783     }
4784   hello = (const struct GNUNET_HELLO_Message *) message;
4785   if (GNUNET_OK != GNUNET_HELLO_get_key (hello, &publicKey))
4786     {
4787 #if DEBUG_TRANSPORT_HELLO
4788       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4789                   "Unable to get public key from `%s' for `%4s'!\n",
4790                   "HELLO",
4791                   GNUNET_i2s (&target));
4792 #endif
4793       GNUNET_break_op (0);
4794       return GNUNET_SYSERR;
4795     }
4796
4797   GNUNET_CRYPTO_hash (&publicKey,
4798                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
4799                       &target.hashPubKey);
4800
4801 #if DEBUG_TRANSPORT_HELLO
4802   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4803               "Received `%s' message for `%4s'\n",
4804               "HELLO",
4805               GNUNET_i2s (&target));
4806 #endif
4807
4808   if (0 == memcmp (&my_identity,
4809                    &target,
4810                    sizeof (struct GNUNET_PeerIdentity)))
4811     {
4812       GNUNET_STATISTICS_update (stats,
4813                                 gettext_noop ("# HELLOs ignored for validation (is my own HELLO)"),
4814                                 1,
4815                                 GNUNET_NO);
4816       return GNUNET_OK;
4817     }
4818   chvc = chvc_head;
4819   while (NULL != chvc)
4820     {
4821       if (GNUNET_HELLO_equals (hello,
4822                                chvc->hello,
4823                                GNUNET_TIME_absolute_get ()).abs_value > 0)
4824         {
4825 #if DEBUG_TRANSPORT_HELLO > 2
4826           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4827                       "Received duplicate `%s' message for `%4s'; ignored\n",
4828                       "HELLO",
4829                       GNUNET_i2s (&target));
4830 #endif
4831           return GNUNET_OK; /* validation already pending */
4832         }
4833       if (GNUNET_HELLO_size(hello) == GNUNET_HELLO_size (chvc->hello))
4834         GNUNET_break (0 != memcmp (hello, chvc->hello,
4835                                    GNUNET_HELLO_size(hello)));
4836       chvc = chvc->next;
4837     }
4838
4839 #if BREAK_TESTS
4840   struct NeighbourList *temp_neighbor = find_neighbour(&target);
4841   if ((NULL != temp_neighbor))
4842     {
4843       fprintf(stderr, "Already know peer, ignoring hello\n");
4844       return GNUNET_OK;
4845     }
4846 #endif
4847
4848 #if DEBUG_TRANSPORT_HELLO > 2
4849   if (plugin != NULL)
4850     {
4851       my_id = GNUNET_strdup(GNUNET_i2s(plugin->env.my_identity));
4852 #if DEBUG_TRANSPORT
4853       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4854                   "%s: Starting validation of `%s' message for `%4s' via '%s' of size %u\n",
4855                   my_id,
4856                   "HELLO",
4857                   GNUNET_i2s (&target),
4858                   plugin->short_name,
4859                   GNUNET_HELLO_size(hello));
4860 #endif
4861       GNUNET_free(my_id);
4862     }
4863 #endif
4864   chvc = GNUNET_malloc (sizeof (struct CheckHelloValidatedContext) + hsize);
4865   chvc->ve_count = 1;
4866   chvc->hello = (const struct GNUNET_HELLO_Message *) &chvc[1];
4867   memcpy (&chvc[1], hello, hsize);
4868   GNUNET_CONTAINER_DLL_insert (chvc_head,
4869                                chvc_tail,
4870                                chvc);
4871   /* finally, check if HELLO was previously validated
4872      (continuation will then schedule actual validation) */
4873   GNUNET_STATISTICS_update (stats,
4874                             gettext_noop ("# peerinfo process hello iterate requests"),
4875                             1,
4876                             GNUNET_NO);
4877   GNUNET_STATISTICS_update (stats,
4878                             gettext_noop ("# outstanding peerinfo iterate requests"),
4879                             1,
4880                             GNUNET_NO);
4881   chvc->piter = GNUNET_PEERINFO_iterate (peerinfo,
4882                                          &target,
4883                                          HELLO_VERIFICATION_TIMEOUT,
4884                                          &check_hello_validated, chvc);
4885   return GNUNET_OK;
4886 }
4887
4888
4889 /**
4890  * The peer specified by the given neighbour has timed-out or a plugin
4891  * has disconnected.  We may either need to do nothing (other plugins
4892  * still up), or trigger a full disconnect and clean up.  This
4893  * function updates our state and does the necessary notifications.
4894  * Also notifies our clients that the neighbour is now officially
4895  * gone.
4896  *
4897  * @param n the neighbour list entry for the peer
4898  * @param check GNUNET_YES to check if ALL addresses for this peer
4899  *              are gone, GNUNET_NO to force a disconnect of the peer
4900  *              regardless of whether other addresses exist.
4901  */
4902 static void
4903 disconnect_neighbour (struct NeighbourList *n, int check)
4904 {
4905   struct ReadyList *rpos;
4906   struct NeighbourList *npos;
4907   struct NeighbourList *nprev;
4908   struct MessageQueue *mq;
4909   struct ForeignAddressList *peer_addresses;
4910   struct ForeignAddressList *peer_pos;
4911
4912   if (GNUNET_YES == check)
4913     {
4914       rpos = n->plugins;
4915       while (NULL != rpos)
4916         {
4917           peer_addresses = rpos->addresses;
4918           while (peer_addresses != NULL)
4919             {
4920               if (GNUNET_YES == peer_addresses->connected)
4921                 {
4922 #if DEBUG_TRANSPORT
4923                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4924                               "NOT Disconnecting from `%4s', still have live addresses!\n",
4925                               GNUNET_i2s (&n->id));
4926 #endif
4927                   return;             /* still connected */
4928                 }
4929               peer_addresses = peer_addresses->next;
4930             }
4931           rpos = rpos->next;
4932         }
4933     }
4934 #if DEBUG_TRANSPORT
4935   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
4936               "Disconnecting from `%4s'\n",
4937               GNUNET_i2s (&n->id));
4938 #endif
4939   /* remove n from neighbours list */
4940   nprev = NULL;
4941   npos = neighbours;
4942   while ((npos != NULL) && (npos != n))
4943     {
4944       nprev = npos;
4945       npos = npos->next;
4946     }
4947   GNUNET_assert (npos != NULL);
4948   if (nprev == NULL)
4949     neighbours = n->next;
4950   else
4951     nprev->next = n->next;
4952
4953   /* notify all clients about disconnect */
4954   if (GNUNET_YES == n->received_pong)
4955     notify_clients_disconnect (&n->id);
4956
4957   /* clean up all plugins, cancel connections and pending transmissions */
4958   while (NULL != (rpos = n->plugins))
4959     {
4960       n->plugins = rpos->next;
4961       rpos->plugin->api->disconnect (rpos->plugin->api->cls, &n->id);
4962       while (rpos->addresses != NULL)
4963         {
4964           peer_pos = rpos->addresses;
4965           rpos->addresses = peer_pos->next;
4966           if (peer_pos->connected == GNUNET_YES)
4967             GNUNET_STATISTICS_update (stats,
4968                                       gettext_noop ("# connected addresses"),
4969                                       -1,
4970                                       GNUNET_NO);
4971           if (GNUNET_YES == peer_pos->validated)
4972             GNUNET_STATISTICS_update (stats,
4973                                       gettext_noop ("# peer addresses considered valid"),
4974                                       -1,
4975                                       GNUNET_NO);
4976           if (GNUNET_SCHEDULER_NO_TASK != peer_pos->revalidate_task)
4977             {
4978               GNUNET_SCHEDULER_cancel (peer_pos->revalidate_task);
4979               peer_pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
4980             }
4981           GNUNET_free(peer_pos->ressources);
4982           peer_pos->ressources = NULL;
4983           GNUNET_free(peer_pos->quality);
4984           peer_pos->ressources = NULL;
4985           GNUNET_free(peer_pos);
4986           ats->stat.recreate_problem = GNUNET_YES;
4987         }
4988       GNUNET_free (rpos);
4989     }
4990
4991   /* free all messages on the queue */
4992   while (NULL != (mq = n->messages_head))
4993     {
4994       GNUNET_STATISTICS_update (stats,
4995                                 gettext_noop ("# bytes in message queue for other peers"),
4996                                 - (int64_t) mq->message_buf_size,
4997                                 GNUNET_NO);
4998       GNUNET_STATISTICS_update (stats,
4999                                 gettext_noop ("# bytes discarded due to disconnect"),
5000                                 mq->message_buf_size,
5001                                 GNUNET_NO);
5002       GNUNET_CONTAINER_DLL_remove (n->messages_head,
5003                                    n->messages_tail,
5004                                    mq);
5005       GNUNET_assert (0 == memcmp(&mq->neighbour_id,
5006                                  &n->id,
5007                                  sizeof(struct GNUNET_PeerIdentity)));
5008       GNUNET_free (mq);
5009     }
5010   if (n->timeout_task != GNUNET_SCHEDULER_NO_TASK)
5011     {
5012       GNUNET_SCHEDULER_cancel (n->timeout_task);
5013       n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
5014     }
5015   if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
5016     {
5017       GNUNET_SCHEDULER_cancel (n->retry_task);
5018       n->retry_task = GNUNET_SCHEDULER_NO_TASK;
5019     }
5020   if (n->piter != NULL)
5021     {
5022       GNUNET_PEERINFO_iterate_cancel (n->piter);
5023       GNUNET_STATISTICS_update (stats,
5024                                 gettext_noop ("# outstanding peerinfo iterate requests"),
5025                                 -1,
5026                                 GNUNET_NO);
5027       n->piter = NULL;
5028     }
5029   /* finally, free n itself */
5030   GNUNET_STATISTICS_update (stats,
5031                             gettext_noop ("# active neighbours"),
5032                             -1,
5033                             GNUNET_NO);
5034   GNUNET_free_non_null (n->pre_connect_message_buffer);
5035   GNUNET_free (n);
5036 }
5037
5038
5039 /**
5040  * We have received a PING message from someone.  Need to send a PONG message
5041  * in response to the peer by any means necessary.
5042  */
5043 static int
5044 handle_ping(void *cls, const struct GNUNET_MessageHeader *message,
5045             const struct GNUNET_PeerIdentity *peer,
5046             struct Session *session,
5047             const char *sender_address,
5048             uint16_t sender_address_len)
5049 {
5050   struct TransportPlugin *plugin = cls;
5051   struct SessionHeader *session_header = (struct SessionHeader*) session;
5052   struct TransportPingMessage *ping;
5053   struct TransportPongMessage *pong;
5054   struct NeighbourList *n;
5055   struct ReadyList *rl;
5056   struct ForeignAddressList *fal;
5057   struct OwnAddressList *oal;
5058   const char *addr;
5059   size_t alen;
5060   size_t slen;
5061
5062   if (ntohs (message->size) < sizeof (struct TransportPingMessage))
5063     {
5064       GNUNET_break_op (0);
5065       return GNUNET_SYSERR;
5066     }
5067
5068   ping = (struct TransportPingMessage *) message;
5069   if (0 != memcmp (&ping->target,
5070                    plugin->env.my_identity,
5071                    sizeof (struct GNUNET_PeerIdentity)))
5072     {
5073 #if DEBUG_TRANSPORT
5074       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5075                   _("Received `%s' message from `%s' destined for `%s' which is not me!\n"),
5076                   "PING",
5077                   (sender_address != NULL)
5078                   ? a2s (plugin->short_name,
5079                          (const struct sockaddr *)sender_address,
5080                          sender_address_len)
5081                   : "<inbound>",
5082                   GNUNET_i2s (&ping->target));
5083 #endif
5084       return GNUNET_SYSERR;
5085     }
5086 #if DEBUG_PING_PONG
5087   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
5088               "Processing `%s' from `%s'\n",
5089               "PING",
5090               (sender_address != NULL)
5091               ? a2s (plugin->short_name,
5092                      (const struct sockaddr *)sender_address,
5093                      sender_address_len)
5094               : "<inbound>");
5095 #endif
5096   GNUNET_STATISTICS_update (stats,
5097                             gettext_noop ("# PING messages received"),
5098                             1,
5099                             GNUNET_NO);
5100   addr = (const char*) &ping[1];
5101   alen = ntohs (message->size) - sizeof (struct TransportPingMessage);
5102   slen = strlen (plugin->short_name) + 1;
5103   if (alen == 0)
5104     {
5105       /* peer wants to confirm that we have an outbound connection to him */
5106       if (session == NULL)
5107         {
5108           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5109                       _("Refusing to create PONG since I do not have a session with `%s'.\n"),
5110                       GNUNET_i2s (peer));
5111           return GNUNET_SYSERR;
5112         }
5113       pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + sender_address_len + slen);
5114       pong->header.size = htons (sizeof (struct TransportPongMessage) + sender_address_len + slen);
5115       pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
5116       pong->purpose.size =
5117         htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
5118                sizeof (uint32_t) +
5119                sizeof (struct GNUNET_TIME_AbsoluteNBO) +
5120                sizeof (struct GNUNET_PeerIdentity) + sender_address_len + slen);
5121       pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING);
5122       pong->challenge = ping->challenge;
5123       pong->addrlen = htonl(sender_address_len + slen);
5124       memcpy(&pong->pid,
5125              peer,
5126              sizeof(struct GNUNET_PeerIdentity));
5127       memcpy (&pong[1],
5128               plugin->short_name,
5129               slen);
5130       if ((sender_address!=NULL) && (sender_address_len > 0))
5131                   memcpy (&((char*)&pong[1])[slen],
5132                           sender_address,
5133                           sender_address_len);
5134       if (GNUNET_TIME_absolute_get_remaining (session_header->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4)
5135         {
5136           /* create / update cached sig */
5137 #if DEBUG_TRANSPORT
5138           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5139                       "Creating PONG signature to indicate active connection.\n");
5140 #endif
5141           session_header->pong_sig_expires = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
5142           pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
5143           GNUNET_assert (GNUNET_OK ==
5144                          GNUNET_CRYPTO_rsa_sign (my_private_key,
5145                                                  &pong->purpose,
5146                                                  &session_header->pong_signature));
5147         }
5148       else
5149         {
5150           pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
5151         }
5152       memcpy (&pong->signature,
5153               &session_header->pong_signature,
5154               sizeof (struct GNUNET_CRYPTO_RsaSignature));
5155
5156
5157     }
5158   else
5159     {
5160       /* peer wants to confirm that this is one of our addresses */
5161       addr += slen;
5162       alen -= slen;
5163       if (GNUNET_OK !=
5164           plugin->api->check_address (plugin->api->cls,
5165                                       addr,
5166                                       alen))
5167         {
5168           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5169                       _("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
5170                       a2s (plugin->short_name,
5171                            addr,
5172                            alen));
5173           return GNUNET_NO;
5174         }
5175       oal = plugin->addresses;
5176       while (NULL != oal)
5177         {
5178           if ( (oal->addrlen == alen) &&
5179                (0 == memcmp (addr,
5180                              &oal[1],
5181                              alen)) )
5182             break;
5183           oal = oal->next;
5184         }
5185       pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + alen + slen);
5186       pong->header.size = htons (sizeof (struct TransportPongMessage) + alen + slen);
5187       pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
5188       pong->purpose.size =
5189         htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
5190                sizeof (uint32_t) +
5191                sizeof (struct GNUNET_TIME_AbsoluteNBO) +
5192                sizeof (struct GNUNET_PeerIdentity) + alen + slen);
5193       pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN);
5194       pong->challenge = ping->challenge;
5195       pong->addrlen = htonl(alen + slen);
5196       memcpy(&pong->pid,
5197              &my_identity,
5198              sizeof(struct GNUNET_PeerIdentity));
5199       memcpy (&pong[1], plugin->short_name, slen);
5200       memcpy (&((char*)&pong[1])[slen], addr, alen);
5201       if ( (oal != NULL) &&
5202            (GNUNET_TIME_absolute_get_remaining (oal->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4) )
5203         {
5204           /* create / update cached sig */
5205 #if DEBUG_TRANSPORT
5206           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5207                       "Creating PONG signature to indicate ownership.\n");
5208 #endif
5209           oal->pong_sig_expires = GNUNET_TIME_absolute_min (oal->expires,
5210                                                             GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
5211           pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
5212           GNUNET_assert (GNUNET_OK ==
5213                          GNUNET_CRYPTO_rsa_sign (my_private_key,
5214                                                  &pong->purpose,
5215                                                  &oal->pong_signature));
5216           memcpy (&pong->signature,
5217                   &oal->pong_signature,
5218                   sizeof (struct GNUNET_CRYPTO_RsaSignature));
5219         }
5220       else if (oal == NULL)
5221         {
5222           /* not using cache (typically DV-only) */
5223           pong->expiration = GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
5224           GNUNET_assert (GNUNET_OK ==
5225                          GNUNET_CRYPTO_rsa_sign (my_private_key,
5226                                                  &pong->purpose,
5227                                                  &pong->signature));
5228         }
5229       else
5230         {
5231           /* can used cached version */
5232           pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
5233           memcpy (&pong->signature,
5234                   &oal->pong_signature,
5235                   sizeof (struct GNUNET_CRYPTO_RsaSignature));
5236         }
5237     }
5238   n = find_neighbour(peer);
5239   GNUNET_assert (n != NULL);
5240   /* first try reliable response transmission */
5241   rl = n->plugins;
5242   while (rl != NULL)
5243     {
5244       fal = rl->addresses;
5245       while (fal != NULL)
5246         {
5247           if (-1 != rl->plugin->api->send (rl->plugin->api->cls,
5248                                            peer,
5249                                            (const char*) pong,
5250                                            ntohs (pong->header.size),
5251                                            TRANSPORT_PONG_PRIORITY,
5252                                            HELLO_VERIFICATION_TIMEOUT,
5253                                            fal->session,
5254                                            fal->addr,
5255                                            fal->addrlen,
5256                                            GNUNET_SYSERR,
5257                                            NULL, NULL))
5258             {
5259               /* done! */
5260               GNUNET_STATISTICS_update (stats,
5261                                         gettext_noop ("# PONGs unicast via reliable transport"),
5262                                         1,
5263                                         GNUNET_NO);
5264               GNUNET_free (pong);
5265               return GNUNET_OK;
5266             }
5267           fal = fal->next;
5268         }
5269       rl = rl->next;
5270     }
5271   /* no reliable method found, do multicast */
5272   GNUNET_STATISTICS_update (stats,
5273                             gettext_noop ("# PONGs multicast to all available addresses"),
5274                             1,
5275                             GNUNET_NO);
5276   rl = n->plugins;
5277   while (rl != NULL)
5278     {
5279       fal = rl->addresses;
5280       while (fal != NULL)
5281         {
5282           transmit_to_peer(NULL, fal,
5283                            TRANSPORT_PONG_PRIORITY,
5284                            HELLO_VERIFICATION_TIMEOUT,
5285                            (const char *)pong,
5286                            ntohs(pong->header.size),
5287                            GNUNET_YES,
5288                            n);
5289           fal = fal->next;
5290         }
5291       rl = rl->next;
5292     }
5293   GNUNET_free(pong);
5294   return GNUNET_OK;
5295 }
5296
5297
5298
5299
5300
5301 /**
5302  * Function called by the plugin for each received message.
5303  * Update data volumes, possibly notify plugins about
5304  * reducing the rate at which they read from the socket
5305  * and generally forward to our receive callback.
5306  *
5307  * @param cls the "struct TransportPlugin *" we gave to the plugin
5308  * @param peer (claimed) identity of the other peer
5309  * @param message the message, NULL if we only care about
5310  *                learning about the delay until we should receive again
5311  * @param ats_data information for automatic transport selection
5312  * @param ats_count number of elements in ats not including 0-terminator
5313  * @param session identifier used for this session (can be NULL)
5314  * @param sender_address binary address of the sender (if observed)
5315  * @param sender_address_len number of bytes in sender_address
5316  * @return how long in ms the plugin should wait until receiving more data
5317  *         (plugins that do not support this, can ignore the return value)
5318  */
5319 static struct GNUNET_TIME_Relative
5320 plugin_env_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
5321                     const struct GNUNET_MessageHeader *message,
5322                     const struct GNUNET_TRANSPORT_ATS_Information *ats_data,
5323                     uint32_t ats_count,
5324                     struct Session *session,
5325                     const char *sender_address,
5326                     uint16_t sender_address_len)
5327 {
5328   struct TransportPlugin *plugin = cls;
5329   struct ReadyList *service_context;
5330   struct ForeignAddressList *peer_address;
5331   uint16_t msize;
5332   struct NeighbourList *n;
5333   struct GNUNET_TIME_Relative ret;
5334   if (is_blacklisted (peer, plugin))
5335     return GNUNET_TIME_UNIT_FOREVER_REL;
5336   uint32_t distance;
5337   int c;
5338
5339   n = find_neighbour (peer);
5340   if (n == NULL)
5341     n = setup_new_neighbour (peer, GNUNET_YES);
5342   service_context = n->plugins;
5343   while ((service_context != NULL) && (plugin != service_context->plugin))
5344     service_context = service_context->next;
5345   GNUNET_assert ((plugin->api->send == NULL) || (service_context != NULL));
5346   peer_address = NULL;
5347   distance = 1;
5348
5349   for (c=0; c<ats_count; c++)
5350   {
5351           if (ntohl(ats_data[c].type) == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
5352           {
5353                   distance = ntohl(ats_data[c].value);
5354           }
5355   }
5356
5357   /* notify ATS about incoming data */
5358   //ats_notify_ats_data(peer, ats_data);
5359
5360
5361   if (message != NULL)
5362     {
5363       if ( (session != NULL) ||
5364            (sender_address != NULL) )
5365         peer_address = add_peer_address (n,
5366                                          plugin->short_name,
5367                                          session,
5368                                          sender_address,
5369                                          sender_address_len);
5370       if (peer_address != NULL)
5371         {
5372
5373       update_addr_ats(peer_address, ats_data, ats_count);
5374       update_addr_value(peer_address, distance, GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
5375
5376       peer_address->distance = distance;
5377           if (GNUNET_YES == peer_address->validated)
5378             mark_address_connected (peer_address);
5379           peer_address->timeout
5380             =
5381             GNUNET_TIME_relative_to_absolute
5382             (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
5383           schedule_next_ping (peer_address);
5384         }
5385       /* update traffic received amount ... */
5386       msize = ntohs (message->size);
5387
5388       GNUNET_STATISTICS_update (stats,
5389                                 gettext_noop ("# bytes received from other peers"),
5390                                 msize,
5391                                 GNUNET_NO);
5392       n->distance = distance;
5393       n->peer_timeout =
5394         GNUNET_TIME_relative_to_absolute
5395         (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
5396       GNUNET_SCHEDULER_cancel (n->timeout_task);
5397       n->timeout_task =
5398         GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
5399                                       &neighbour_timeout_task, n);
5400       if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
5401         {
5402           /* dropping message due to frequent inbound volume violations! */
5403           GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
5404                       GNUNET_ERROR_TYPE_BULK,
5405                       _
5406                       ("Dropping incoming message due to repeated bandwidth quota (%u b/s) violations (total of %u).\n"),
5407                       n->in_tracker.available_bytes_per_s__,
5408                       n->quota_violation_count);
5409           GNUNET_STATISTICS_update (stats,
5410                                     gettext_noop ("# bandwidth quota violations by other peers"),
5411                                     1,
5412                                     GNUNET_NO);
5413           return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
5414         }
5415     if ((ntohs(message->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ATS) &&
5416         (ntohs(message->size) == (sizeof (struct GNUNET_MessageHeader) + sizeof (uint32_t))))
5417     {
5418         uint32_t value =  ntohl(*((uint32_t *) &message[1]));
5419         //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GNUNET_MESSAGE_TYPE_TRANSPORT_ATS: %i \n", value);
5420         /* Force ressource and quality update */
5421         if (value == 4)
5422         {
5423                 ats->stat.modified_resources = GNUNET_YES;
5424                 ats->stat.modified_quality = GNUNET_YES;
5425         }
5426         /* Force cost update */
5427         if (value == 3)
5428                 ats->stat.modified_resources = GNUNET_YES;
5429         /* Force quality update */
5430         if (value == 2)
5431                 ats->stat.modified_quality = GNUNET_YES;
5432         /* Force full rebuild */
5433         if (value == 1)
5434                 ats->stat.recreate_problem = GNUNET_YES;
5435     }
5436
5437 #if DEBUG_PING_PONG
5438           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5439                       "Received message of type %u and size %u from `%4s', sending to all clients.\n",
5440                       ntohs (message->type),
5441                       ntohs (message->size),
5442                       GNUNET_i2s (peer));
5443 #endif
5444       switch (ntohs (message->type))
5445         {
5446         case GNUNET_MESSAGE_TYPE_HELLO:
5447           GNUNET_STATISTICS_update (stats,
5448                                     gettext_noop ("# HELLO messages received from other peers"),
5449                                     1,
5450                                     GNUNET_NO);
5451           process_hello (plugin, message);
5452           break;
5453         case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
5454           handle_ping (plugin, message, peer, session, sender_address, sender_address_len);
5455           break;
5456         case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
5457           handle_pong (plugin, message, peer, sender_address, sender_address_len);
5458           break;
5459         case GNUNET_MESSAGE_TYPE_TRANSPORT_ATS:
5460           break;
5461         default:
5462           handle_payload_message (message, n);
5463           break;
5464         }
5465     }
5466   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 0);
5467   if (ret.rel_value > 0)
5468     {
5469 #if DEBUG_TRANSPORT
5470       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5471                   "Throttling read (%llu bytes excess at %u b/s), waiting %llums before reading more.\n",
5472                   (unsigned long long) n->in_tracker.consumption_since_last_update__,
5473                   (unsigned int) n->in_tracker.available_bytes_per_s__,
5474                   (unsigned long long) ret.rel_value);
5475 #endif
5476       GNUNET_STATISTICS_update (stats,
5477                                 gettext_noop ("# ms throttling suggested"),
5478                                 (int64_t) ret.rel_value,
5479                                 GNUNET_NO);
5480     }
5481   return ret;
5482 }
5483
5484 /**
5485  * Handle START-message.  This is the first message sent to us
5486  * by any client which causes us to add it to our list.
5487  *
5488  * @param cls closure (always NULL)
5489  * @param client identification of the client
5490  * @param message the actual message
5491  */
5492 static void
5493 handle_start (void *cls,
5494               struct GNUNET_SERVER_Client *client,
5495               const struct GNUNET_MessageHeader *message)
5496 {
5497   const struct StartMessage *start;
5498   struct TransportClient *c;
5499   struct ConnectInfoMessage * cim;
5500   struct NeighbourList *n;
5501   uint32_t ats_count;
5502   size_t size;
5503
5504   start = (const struct StartMessage*) message;
5505 #if DEBUG_TRANSPORT
5506   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5507               "Received `%s' request from client\n", "START");
5508 #endif
5509   c = clients;
5510   while (c != NULL)
5511     {
5512       if (c->client == client)
5513         {
5514           /* client already on our list! */
5515           GNUNET_break (0);
5516           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5517           return;
5518         }
5519       c = c->next;
5520     }
5521   if ( (GNUNET_NO != ntohl (start->do_check)) &&
5522        (0 != memcmp (&start->self,
5523                      &my_identity,
5524                      sizeof (struct GNUNET_PeerIdentity))) )
5525     {
5526       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5527                   _("Rejecting control connection from peer `%s', which is not me!\n"),
5528                   GNUNET_i2s (&start->self));
5529       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5530       return;
5531     }
5532   c = GNUNET_malloc (sizeof (struct TransportClient));
5533   c->next = clients;
5534   clients = c;
5535   c->client = client;
5536   if (our_hello != NULL)
5537   {
5538 #if DEBUG_TRANSPORT
5539       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5540                   "Sending our own `%s' to new client\n", "HELLO");
5541 #endif
5542       transmit_to_client (c,
5543                           (const struct GNUNET_MessageHeader *) our_hello,
5544                           GNUNET_NO);
5545       /* tell new client about all existing connections */
5546       ats_count = 2;
5547       size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
5548       if (size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
5549       {
5550           GNUNET_break(0);
5551       }
5552       cim = GNUNET_malloc (size);
5553       cim->header.size = htons (size);
5554       cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
5555       cim->ats_count = htonl(ats_count);
5556       (&(cim->ats))[2].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
5557       (&(cim->ats))[2].value = htonl (0);
5558       n = neighbours;
5559       while (n != NULL)
5560           {
5561                   if (GNUNET_YES == n->received_pong)
5562                   {
5563                           (&(cim->ats))[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
5564                           (&(cim->ats))[0].value = htonl (n->distance);
5565                           (&(cim->ats))[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
5566                           (&(cim->ats))[1].value = htonl ((uint32_t) n->latency.rel_value);
5567                           cim->id = n->id;
5568                           transmit_to_client (c, &cim->header, GNUNET_NO);
5569                   }
5570             n = n->next;
5571       }
5572       GNUNET_free (cim);
5573   }
5574   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5575 }
5576
5577
5578 /**
5579  * Handle HELLO-message.
5580  *
5581  * @param cls closure (always NULL)
5582  * @param client identification of the client
5583  * @param message the actual message
5584  */
5585 static void
5586 handle_hello (void *cls,
5587               struct GNUNET_SERVER_Client *client,
5588               const struct GNUNET_MessageHeader *message)
5589 {
5590   int ret;
5591
5592   GNUNET_STATISTICS_update (stats,
5593                             gettext_noop ("# HELLOs received from clients"),
5594                             1,
5595                             GNUNET_NO);
5596   ret = process_hello (NULL, message);
5597   GNUNET_SERVER_receive_done (client, ret);
5598 }
5599
5600
5601 /**
5602  * Closure for 'transmit_client_message'; followed by
5603  * 'msize' bytes of the actual message.
5604  */
5605 struct TransmitClientMessageContext
5606 {
5607   /**
5608    * Client on whom's behalf we are sending.
5609    */
5610   struct GNUNET_SERVER_Client *client;
5611
5612   /**
5613    * Timeout for the transmission.
5614    */
5615   struct GNUNET_TIME_Absolute timeout;
5616
5617   /**
5618    * Message priority.
5619    */
5620   uint32_t priority;
5621
5622   /**
5623    * Size of the message in bytes.
5624    */
5625   uint16_t msize;
5626 };
5627
5628
5629 /**
5630  * Schedule transmission of a message we got from a client to a peer.
5631  *
5632  * @param cls the 'struct TransmitClientMessageContext*'
5633  * @param n destination, or NULL on error (in that case, drop the message)
5634  */
5635 static void
5636 transmit_client_message (void *cls,
5637                          struct NeighbourList *n)
5638 {
5639   struct TransmitClientMessageContext *tcmc = cls;
5640   struct TransportClient *tc;
5641
5642   tc = clients;
5643   while ((tc != NULL) && (tc->client != tcmc->client))
5644     tc = tc->next;
5645
5646   if (n != NULL)
5647     {
5648       transmit_to_peer (tc, NULL, tcmc->priority,
5649                         GNUNET_TIME_absolute_get_remaining (tcmc->timeout),
5650                         (char *)&tcmc[1],
5651                         tcmc->msize, GNUNET_NO, n);
5652     }
5653   GNUNET_SERVER_receive_done (tcmc->client, GNUNET_OK);
5654   GNUNET_SERVER_client_drop (tcmc->client);
5655   GNUNET_free (tcmc);
5656 }
5657
5658
5659 /**
5660  * Handle SEND-message.
5661  *
5662  * @param cls closure (always NULL)
5663  * @param client identification of the client
5664  * @param message the actual message
5665  */
5666 static void
5667 handle_send (void *cls,
5668              struct GNUNET_SERVER_Client *client,
5669              const struct GNUNET_MessageHeader *message)
5670 {
5671   const struct OutboundMessage *obm;
5672   const struct GNUNET_MessageHeader *obmm;
5673   struct TransmitClientMessageContext *tcmc;
5674   uint16_t size;
5675   uint16_t msize;
5676
5677   size = ntohs (message->size);
5678   if (size <
5679       sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
5680     {
5681       GNUNET_break (0);
5682       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5683       return;
5684     }
5685   GNUNET_STATISTICS_update (stats,
5686                             gettext_noop ("# payload received for other peers"),
5687                             size,
5688                             GNUNET_NO);
5689   obm = (const struct OutboundMessage *) message;
5690   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
5691   msize = size - sizeof (struct OutboundMessage);
5692 #if DEBUG_TRANSPORT
5693   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5694               "Received `%s' request from client with target `%4s' and message of type %u and size %u\n",
5695               "SEND", GNUNET_i2s (&obm->peer),
5696               ntohs (obmm->type),
5697               msize);
5698 #endif
5699   tcmc = GNUNET_malloc (sizeof (struct TransmitClientMessageContext) + msize);
5700   tcmc->client = client;
5701   tcmc->priority = ntohl (obm->priority);
5702   tcmc->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh (obm->timeout));
5703   tcmc->msize = msize;
5704   /* FIXME: this memcpy can be up to 7% of our total runtime */
5705   memcpy (&tcmc[1], obmm, msize);
5706   GNUNET_SERVER_client_keep (client);
5707   setup_peer_check_blacklist (&obm->peer, GNUNET_YES,
5708                               &transmit_client_message,
5709                               tcmc);
5710 }
5711
5712
5713 /**
5714  * Handle request connect message
5715  *
5716  * @param cls closure (always NULL)
5717  * @param client identification of the client
5718  * @param message the actual message
5719  */
5720 static void
5721 handle_request_connect (void *cls,
5722                         struct GNUNET_SERVER_Client *client,
5723                         const struct GNUNET_MessageHeader *message)
5724 {
5725   const struct TransportRequestConnectMessage *trcm =
5726     (const struct TransportRequestConnectMessage *) message;
5727
5728   GNUNET_STATISTICS_update (stats,
5729                             gettext_noop ("# REQUEST CONNECT messages received"),
5730                             1,
5731                             GNUNET_NO);
5732 #if DEBUG_TRANSPORT
5733   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
5734              "Received a request connect message for peer `%s'\n",
5735              GNUNET_i2s(&trcm->peer));
5736 #endif
5737   setup_peer_check_blacklist (&trcm->peer, GNUNET_YES,
5738                               NULL, NULL);
5739   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5740 }
5741
5742
5743 /**
5744  * Handle SET_QUOTA-message.
5745  *
5746  * @param cls closure (always NULL)
5747  * @param client identification of the client
5748  * @param message the actual message
5749  */
5750 static void
5751 handle_set_quota (void *cls,
5752                   struct GNUNET_SERVER_Client *client,
5753                   const struct GNUNET_MessageHeader *message)
5754 {
5755   const struct QuotaSetMessage *qsm =
5756     (const struct QuotaSetMessage *) message;
5757   struct NeighbourList *n;
5758
5759   GNUNET_STATISTICS_update (stats,
5760                             gettext_noop ("# SET QUOTA messages received"),
5761                             1,
5762                             GNUNET_NO);
5763   n = find_neighbour (&qsm->peer);
5764   if (n == NULL)
5765     {
5766       GNUNET_SERVER_receive_done (client, GNUNET_OK);
5767       GNUNET_STATISTICS_update (stats,
5768                                 gettext_noop ("# SET QUOTA messages ignored (no such peer)"),
5769                                 1,
5770                                 GNUNET_NO);
5771       return;
5772     }
5773 #if DEBUG_TRANSPORT
5774   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5775               "Received `%s' request (new quota %u, old quota %u) from client for peer `%4s'\n",
5776               "SET_QUOTA",
5777               (unsigned int) ntohl (qsm->quota.value__),
5778               (unsigned int) n->in_tracker.available_bytes_per_s__,
5779               GNUNET_i2s (&qsm->peer));
5780 #endif
5781   GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker,
5782                                          qsm->quota);
5783   if (0 == ntohl (qsm->quota.value__))
5784     {
5785 #if DEBUG_TRANSPORT
5786       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5787                 "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&n->id),
5788                 "SET_QUOTA");
5789 #endif
5790       disconnect_neighbour (n, GNUNET_NO);
5791     }
5792   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5793 }
5794
5795
5796 /**
5797  * Take the given address and append it to the set of results sent back to
5798  * the client.
5799  *
5800  * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
5801  * @param address the resolved name, NULL to indicate the last response
5802  */
5803 static void
5804 transmit_address_to_client (void *cls, const char *address)
5805 {
5806   struct GNUNET_SERVER_TransmitContext *tc = cls;
5807   size_t slen;
5808
5809   if (NULL == address)
5810     slen = 0;
5811   else
5812     slen = strlen (address) + 1;
5813
5814   GNUNET_SERVER_transmit_context_append_data (tc, address, slen,
5815                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
5816   if (NULL == address)
5817     GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
5818 }
5819
5820
5821 /**
5822  * Handle AddressLookup-message.
5823  *
5824  * @param cls closure (always NULL)
5825  * @param client identification of the client
5826  * @param message the actual message
5827  */
5828 static void
5829 handle_address_lookup (void *cls,
5830                        struct GNUNET_SERVER_Client *client,
5831                        const struct GNUNET_MessageHeader *message)
5832 {
5833   const struct AddressLookupMessage *alum;
5834   struct TransportPlugin *lsPlugin;
5835   const char *nameTransport;
5836   const char *address;
5837   uint16_t size;
5838   struct GNUNET_SERVER_TransmitContext *tc;
5839   struct GNUNET_TIME_Absolute timeout;
5840   struct GNUNET_TIME_Relative rtimeout;
5841   int32_t numeric;
5842
5843   size = ntohs (message->size);
5844   if (size < sizeof (struct AddressLookupMessage))
5845     {
5846       GNUNET_break_op (0);
5847       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5848       return;
5849     }
5850   alum = (const struct AddressLookupMessage *) message;
5851   uint32_t addressLen = ntohl (alum->addrlen);
5852   if (size <= sizeof (struct AddressLookupMessage) + addressLen)
5853     {
5854       GNUNET_break_op (0);
5855       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5856       return;
5857     }
5858   address = (const char *) &alum[1];
5859   nameTransport = (const char *) &address[addressLen];
5860   if (nameTransport
5861       [size - sizeof (struct AddressLookupMessage) - addressLen - 1] != '\0')
5862     {
5863       GNUNET_break_op (0);
5864       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5865       return;
5866     }
5867   timeout = GNUNET_TIME_absolute_ntoh (alum->timeout);
5868   rtimeout = GNUNET_TIME_absolute_get_remaining (timeout);
5869   numeric = ntohl (alum->numeric_only);
5870   lsPlugin = find_transport (nameTransport);
5871   if (NULL == lsPlugin)
5872     {
5873       tc = GNUNET_SERVER_transmit_context_create (client);
5874       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
5875                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
5876       GNUNET_SERVER_transmit_context_run (tc, rtimeout);
5877       return;
5878     }
5879   tc = GNUNET_SERVER_transmit_context_create (client);
5880   lsPlugin->api->address_pretty_printer (lsPlugin->api->cls,
5881                                          nameTransport,
5882                                          address, addressLen,
5883                                          numeric,
5884                                          rtimeout,
5885                                          &transmit_address_to_client, tc);
5886 }
5887
5888
5889 /**
5890  * Setup the environment for this plugin.
5891  */
5892 static void
5893 create_environment (struct TransportPlugin *plug)
5894 {
5895   plug->env.cfg = cfg;
5896   plug->env.my_identity = &my_identity;
5897   plug->env.our_hello = &our_hello;
5898   plug->env.cls = plug;
5899   plug->env.receive = &plugin_env_receive;
5900   plug->env.notify_address = &plugin_env_notify_address;
5901   plug->env.session_end = &plugin_env_session_end;
5902   plug->env.max_connections = max_connect_per_transport;
5903   plug->env.stats = stats;
5904 }
5905
5906
5907 /**
5908  * Start the specified transport (load the plugin).
5909  */
5910 static void
5911 start_transport (struct GNUNET_SERVER_Handle *server,
5912                  const char *name)
5913 {
5914   struct TransportPlugin *plug;
5915   char *libname;
5916
5917   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5918               _("Loading `%s' transport plugin\n"), name);
5919   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", name);
5920   plug = GNUNET_malloc (sizeof (struct TransportPlugin));
5921   create_environment (plug);
5922   plug->short_name = GNUNET_strdup (name);
5923   plug->lib_name = libname;
5924   plug->next = plugins;
5925   plugins = plug;
5926   plug->api = GNUNET_PLUGIN_load (libname, &plug->env);
5927   if (plug->api == NULL)
5928     {
5929       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5930                   _("Failed to load transport plugin for `%s'\n"), name);
5931       GNUNET_free (plug->short_name);
5932       plugins = plug->next;
5933       GNUNET_free (libname);
5934       GNUNET_free (plug);
5935     }
5936 }
5937
5938
5939 /**
5940  * Called whenever a client is disconnected.  Frees our
5941  * resources associated with that client.
5942  *
5943  * @param cls closure
5944  * @param client identification of the client
5945  */
5946 static void
5947 client_disconnect_notification (void *cls,
5948                                 struct GNUNET_SERVER_Client *client)
5949 {
5950   struct TransportClient *pos;
5951   struct TransportClient *prev;
5952   struct ClientMessageQueueEntry *mqe;
5953   struct Blacklisters *bl;
5954   struct BlacklistCheck *bc;
5955
5956   if (client == NULL)
5957     return;
5958 #if DEBUG_TRANSPORT
5959   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
5960               "Client disconnected, cleaning up.\n");
5961 #endif
5962   /* clean up blacklister */
5963   bl = bl_head;
5964   while (bl != NULL)
5965     {
5966       if (bl->client == client)
5967         {
5968           bc = bc_head;
5969           while (bc != NULL)
5970             {
5971               if (bc->bl_pos == bl)
5972                 {
5973                   bc->bl_pos = bl->next;
5974                   if (bc->th != NULL)
5975                     {
5976                       GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
5977                       bc->th = NULL;
5978                     }
5979                   if (bc->task == GNUNET_SCHEDULER_NO_TASK)
5980                     bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
5981                                                          bc);
5982                   break;
5983                 }
5984               bc = bc->next;
5985             }
5986           GNUNET_CONTAINER_DLL_remove (bl_head,
5987                                        bl_tail,
5988                                        bl);
5989           GNUNET_SERVER_client_drop (bl->client);
5990           GNUNET_free (bl);
5991           break;
5992         }
5993       bl = bl->next;
5994     }
5995   /* clean up 'normal' clients */
5996   prev = NULL;
5997   pos = clients;
5998   while ((pos != NULL) && (pos->client != client))
5999     {
6000       prev = pos;
6001       pos = pos->next;
6002     }
6003   if (pos == NULL)
6004     return;
6005   while (NULL != (mqe = pos->message_queue_head))
6006     {
6007       GNUNET_CONTAINER_DLL_remove (pos->message_queue_head,
6008                                    pos->message_queue_tail,
6009                                    mqe);
6010       pos->message_count--;
6011       GNUNET_free (mqe);
6012     }
6013   if (prev == NULL)
6014     clients = pos->next;
6015   else
6016     prev->next = pos->next;
6017   if (GNUNET_YES == pos->tcs_pending)
6018     {
6019       pos->client = NULL;
6020       return;
6021     }
6022   if (pos->th != NULL)
6023     {
6024       GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
6025       pos->th = NULL;
6026     }
6027   GNUNET_break (0 == pos->message_count);
6028   GNUNET_free (pos);
6029 }
6030
6031
6032 /**
6033  * Function called when the service shuts down.  Unloads our plugins
6034  * and cancels pending validations.
6035  *
6036  * @param cls closure, unused
6037  * @param tc task context (unused)
6038  */
6039 static void
6040 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
6041 {
6042   struct TransportPlugin *plug;
6043   struct OwnAddressList *al;
6044   struct CheckHelloValidatedContext *chvc;
6045
6046   while (neighbours != NULL)
6047     {
6048 #if DEBUG_TRANSPORT
6049       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6050                   "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&neighbours->id),
6051                   "SHUTDOWN_TASK");
6052 #endif
6053       disconnect_neighbour (neighbours, GNUNET_NO);
6054     }
6055 #if DEBUG_TRANSPORT
6056   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6057               "Transport service is unloading plugins...\n");
6058 #endif
6059   while (NULL != (plug = plugins))
6060     {
6061       plugins = plug->next;
6062       if (plug->address_update_task != GNUNET_SCHEDULER_NO_TASK)
6063         {
6064           GNUNET_SCHEDULER_cancel (plug->address_update_task);
6065           plug->address_update_task = GNUNET_SCHEDULER_NO_TASK;
6066         }
6067       GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
6068       GNUNET_free (plug->lib_name);
6069       GNUNET_free (plug->short_name);
6070       while (NULL != (al = plug->addresses))
6071         {
6072           plug->addresses = al->next;
6073           GNUNET_free (al);
6074         }
6075       GNUNET_free (plug);
6076     }
6077   if (my_private_key != NULL)
6078     GNUNET_CRYPTO_rsa_key_free (my_private_key);
6079   GNUNET_free_non_null (our_hello);
6080
6081   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
6082                                          &abort_validation,
6083                                          NULL);
6084   GNUNET_CONTAINER_multihashmap_destroy (validation_map);
6085   validation_map = NULL;
6086
6087   ats_shutdown(ats);
6088
6089   /* free 'chvc' data structure */
6090   while (NULL != (chvc = chvc_head))
6091     {
6092       chvc_head = chvc->next;
6093       if (chvc->piter != NULL)
6094         {
6095           GNUNET_PEERINFO_iterate_cancel (chvc->piter);
6096           GNUNET_STATISTICS_update (stats,
6097                                     gettext_noop ("# outstanding peerinfo iterate requests"),
6098                                     -1,
6099                                     GNUNET_NO);
6100           chvc->ve_count --;
6101         }
6102       else
6103           GNUNET_break (0);
6104       GNUNET_assert (chvc->ve_count == 0);
6105       GNUNET_free (chvc);
6106     }
6107   chvc_tail = NULL;
6108
6109   if (stats != NULL)
6110     {
6111       GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
6112       stats = NULL;
6113     }
6114   if (peerinfo != NULL)
6115     {
6116       GNUNET_PEERINFO_disconnect (peerinfo);
6117       peerinfo = NULL;
6118     }
6119   /* Can we assume those are gone by now, or do we need to clean up
6120      explicitly!? */
6121   GNUNET_break (bl_head == NULL);
6122   GNUNET_break (bc_head == NULL);
6123 }
6124
6125 #if HAVE_LIBGLPK
6126 static int ats_evaluate_results (int result, int solution, char * problem)
6127 {
6128         int cont = GNUNET_NO;
6129         int error_kind = GNUNET_ERROR_TYPE_DEBUG;
6130 #if DEBUG_ATS
6131         error_kind = GNUNET_ERROR_TYPE_ERROR;
6132 #endif
6133
6134         switch (result) {
6135         case GLP_ESTOP  :    /* search terminated by application */
6136                 GNUNET_log (error_kind, "%s , Search terminated by application\n", problem);
6137                 break;
6138         case GLP_EITLIM :    /* iteration limit exceeded */
6139                 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s Iteration limit exceeded\n", problem);
6140                 break;
6141         break;
6142         case GLP_ETMLIM :    /* time limit exceeded */
6143                 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s Time limit exceeded\n", problem);
6144         break;
6145         case GLP_ENOPFS :    /* no primal feasible solution */
6146         case GLP_ENODFS :    /* no dual feasible solution */
6147                 GNUNET_log (error_kind, "%s No feasible solution\n", problem);
6148         break;
6149
6150         case GLP_EBADB  :    /* invalid basis */
6151         case GLP_ESING  :    /* singular matrix */
6152         case GLP_ECOND  :    /* ill-conditioned matrix */
6153         case GLP_EBOUND :    /* invalid bounds */
6154         case GLP_EFAIL  :    /* solver failed */
6155         case GLP_EOBJLL :    /* objective lower limit reached */
6156         case GLP_EOBJUL :    /* objective upper limit reached */
6157         case GLP_EROOT  :    /* root LP optimum not provided */
6158                 GNUNET_log (error_kind, "%s Invalid Input data: %i\n", problem, result);
6159         break;
6160
6161         case 0:
6162                         GNUNET_log (error_kind, "%s Problem has been solved\n", problem);
6163         break;
6164         }
6165
6166         switch (solution) {
6167                 case GLP_UNDEF:
6168                         GNUNET_log (error_kind, "%s solution is undeﬁned\n", problem);
6169                         break;
6170                 case GLP_OPT:
6171                         GNUNET_log (error_kind, "%s solution is optimal\n", problem);
6172                         cont=GNUNET_YES;
6173                         break;
6174                 case GLP_FEAS:
6175                         GNUNET_log (error_kind, "%s solution is %s feasible, however, its optimality (or non-optimality) has not been proven, \n", problem, (0==strcmp(problem,"LP")?"":"integer"));
6176                         cont=GNUNET_YES;
6177                         break;
6178                 case GLP_NOFEAS:
6179                         GNUNET_log (error_kind, "%s problem has no %sfeasible solution\n", problem,  (0==strcmp(problem,"LP")?"":"integer "));
6180                         break;
6181                 case GLP_INFEAS:
6182                         GNUNET_log (error_kind, "%s problem is infeasible \n", problem);
6183                         break;
6184                 case GLP_UNBND:
6185                         GNUNET_log (error_kind, "%s problem is unbounded \n", problem);
6186                 default:
6187                         break;
6188         }
6189 return cont;
6190 }
6191
6192 static void ats_solve_problem (unsigned int max_it, unsigned int  max_dur, unsigned int c_peers, unsigned int  c_mechs, struct ATS_stat *stat)
6193 {
6194         int result;
6195         int lp_solution;
6196         int mlp_solution;
6197
6198         // Solving simplex
6199
6200         glp_smcp opt_lp;
6201         glp_init_smcp(&opt_lp);
6202 #if VERBOSE_ATS
6203         opt_lp.msg_lev = GLP_MSG_ALL;
6204 #else
6205         opt_lp.msg_lev = GLP_MSG_OFF;
6206 #endif
6207
6208         // setting iteration limit
6209         opt_lp.it_lim = max_it;
6210         // maximum duration
6211         opt_lp.tm_lim = max_dur;
6212
6213         if (ats->stat.recreate_problem == GNUNET_YES)
6214                 opt_lp.presolve = GLP_ON;
6215         result = glp_simplex(ats->prob, &opt_lp);
6216         lp_solution =  glp_get_status (ats->prob);
6217
6218         if ((result == GLP_ETMLIM) || (result == GLP_ETMLIM))
6219         {
6220                 ats->stat.valid = GNUNET_NO;
6221                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ATS exceeded time or iteration limit!\n");
6222                 return;
6223         }
6224
6225         if (ats_evaluate_results(result, lp_solution, "LP") == GNUNET_YES)
6226         {
6227                         stat->valid = GNUNET_YES;
6228         }
6229         else
6230         {
6231                 ats->stat.simplex_rerun_required = GNUNET_YES;
6232                 opt_lp.presolve = GLP_ON;
6233                 result = glp_simplex(ats->prob, &opt_lp);
6234                 lp_solution =  glp_get_status (ats->prob);
6235
6236                 // TODO: Remove if this does not appear until release
6237                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "EXECUTED SIMPLEX WITH PRESOLVER! %i \n", lp_solution);
6238
6239                 if (ats_evaluate_results(result, lp_solution, "LP") != GNUNET_YES)
6240                 {
6241                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "After execution simplex with presolver: STILL INVALID!\n");
6242                         char * filename;
6243                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%llu.mlp",ats->stat.c_peers, ats->stat.c_mechs, GNUNET_TIME_absolute_get().abs_value);
6244                         glp_write_lp (ats->prob, NULL, filename);
6245                         GNUNET_free (filename);
6246                         stat->valid = GNUNET_NO;
6247                         ats->stat.recreate_problem = GNUNET_YES;
6248                         return;
6249                 }
6250                 stat->valid = GNUNET_YES;
6251         }
6252
6253         // Solving mlp
6254         glp_iocp opt_mlp;
6255         glp_init_iocp(&opt_mlp);
6256         // maximum duration
6257         opt_mlp.tm_lim = max_dur;
6258         // output level
6259 #if VERBOSE_ATS
6260         opt_mlp.msg_lev = GLP_MSG_ALL;
6261 #else
6262         opt_mlp.msg_lev = GLP_MSG_OFF;
6263 #endif
6264
6265         result = glp_intopt (ats->prob, &opt_mlp);
6266         mlp_solution =  glp_mip_status (ats->prob);
6267         stat->solution = mlp_solution;
6268
6269         if (ats_evaluate_results(result, mlp_solution, "MLP") == GNUNET_YES)
6270         {
6271                 stat->valid = GNUNET_YES;
6272         }
6273         else
6274         {
6275                 // TODO: Remove if this does not appear until release
6276                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,  "MLP SOLUTION INVALID: %i\n", lp_solution);
6277                 stat->valid = GNUNET_NO;
6278         }
6279
6280 /*
6281         int check;
6282         int error = GNUNET_NO;
6283         double bw;
6284         struct ATS_mechanism *t = NULL;
6285         for (c=1; c<= (c_peers); c++ )
6286         {
6287                 check = GNUNET_NO;
6288                 t = peers[c].m_head;
6289                 while (t!=NULL)
6290                 {
6291                         bw = glp_get_col_prim(prob, t->col_index);
6292                         if (bw > 1.0)
6293                         {
6294 #if VERBOSE_ATS
6295                                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[%i][%i] `%s' %s %s %f\n", c, t->col_index, GNUNET_h2s(&peers[c].peer.hashPubKey), t->plugin->short_name, glp_get_col_name(prob,t->col_index), bw);
6296 #endif
6297                                 if (check ==GNUNET_YES)
6298                                 {
6299                                         glp_write_sol(prob, "invalid_solution.mlp");
6300                                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid solution, check invalid_solution.mlp");
6301                                         GNUNET_STATISTICS_update (stats, "ATS invalid solutions", 1, GNUNET_NO);
6302                                         error = GNUNET_YES;
6303                                 }
6304                                 if (check ==GNUNET_NO)
6305                                         check = GNUNET_YES;
6306                         }
6307                         t = t->next;
6308                 }
6309         }*/
6310
6311 #if VERBOSE_ATS
6312         if (glp_get_col_prim(ats->prob,2*c_mechs+1) != 1)
6313         {
6314         int c;
6315         for (c=1; c<= available_quality_metrics; c++ )
6316         {
6317                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n", glp_get_col_name(ats->prob,2*c_mechs+3+c), glp_get_col_prim(ats->prob,2*c_mechs+3+c));
6318         }
6319         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n", glp_get_col_name(ats->prob,2*c_mechs+1), glp_get_col_prim(ats->prob,2*c_mechs+1));
6320         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n", glp_get_col_name(ats->prob,2*c_mechs+2), glp_get_col_prim(ats->prob,2*c_mechs+2));
6321         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s %f\n", glp_get_col_name(ats->prob,2*c_mechs+3), glp_get_col_prim(ats->prob,2*c_mechs+3));
6322         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "objective value:  %f\n", glp_mip_obj_val(ats->prob));
6323         }
6324 #endif
6325 }
6326
6327 static void ats_delete_problem ()
6328 {
6329 #if DEBUG_ATS
6330         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Deleting problem\n");
6331 #endif
6332         int c;
6333
6334         for (c=0; c< (ats->stat).c_mechs; c++)
6335                 GNUNET_free_non_null (ats->mechanisms[c].rc);
6336
6337
6338         if (ats->mechanisms!=NULL)
6339         {
6340                 GNUNET_free(ats->mechanisms);
6341                 ats->mechanisms = NULL;
6342         }
6343
6344         if (ats->peers!=NULL)
6345         {
6346                 GNUNET_free(ats->peers);
6347                 ats->peers = NULL;
6348         }
6349
6350         if (ats->prob != NULL)
6351         {
6352                 glp_delete_prob(ats->prob);
6353                 ats->prob = NULL;
6354         }
6355
6356         ats->stat.begin_cr = GNUNET_SYSERR;
6357         ats->stat.begin_qm = GNUNET_SYSERR;
6358         ats->stat.c_mechs = 0;
6359         ats->stat.c_peers = 0;
6360         ats->stat.end_cr = GNUNET_SYSERR;
6361         ats->stat.end_qm = GNUNET_SYSERR;
6362         ats->stat.solution = GNUNET_SYSERR;
6363         ats->stat.valid = GNUNET_SYSERR;
6364 }
6365
6366
6367 static void ats_update_problem_qm ()
6368 {
6369         int array_index;
6370         int row_index;
6371         int c, c2;
6372         int c_q_metrics = available_quality_metrics;
6373
6374         int *ja    = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (int));
6375         double *ar = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (double));
6376 #if DEBUG_ATS
6377                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
6378 #endif
6379         row_index = ats->stat.begin_qm;
6380
6381         for (c=1; c <= c_q_metrics; c++)
6382         {
6383                 array_index = 1;
6384                 double value = 1;
6385 #if VERBOSE_ATS
6386                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6387 #endif
6388
6389                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6390                 for (c2=1; c2<=ats->stat.c_mechs; c2++)
6391                 {
6392                         ja[array_index] = c2;
6393
6394                         GNUNET_assert (ats->mechanisms[c2].addr != NULL);
6395                         GNUNET_assert (ats->mechanisms[c2].peer != NULL);
6396
6397                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
6398                         {
6399                                 double v0 = 0, v1 = 0, v2 = 0;
6400
6401                                 v0 = ats->mechanisms[c2].addr->quality[c-1].values[0];
6402                                 if (v1 < 1) v0 = 0.1;
6403                                 v1 = ats->mechanisms[c2].addr->quality[c-1].values[1];
6404                                 if (v1 < 1) v0 = 0.1;
6405                                 v2 = ats->mechanisms[c2].addr->quality[c-1].values[2];
6406                                 if (v1 < 1) v0 = 0.1;
6407                                 value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
6408                                 //value = 1;
6409                         }
6410                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
6411                         {
6412                                 double v0 = 0, v1 = 0, v2 = 0;
6413                                 v0 = ats->mechanisms[c2].addr->quality[c-1].values[0];
6414                                 if (v0 < 1) v0 = 1;
6415                                 v1 = ats->mechanisms[c2].addr->quality[c-1].values[1];
6416                                 if (v1 < 1) v1 = 1;
6417                                 v2 = ats->mechanisms[c2].addr->quality[c-1].values[2];
6418                                 if (v2 < 1) v2 = 1;
6419                                 value =  (v0 + 2 * v1 + 3 * v2) / 6.0;
6420                                 if (value >= 1)
6421                                         value =  (double) 10 / value;
6422                                 else
6423                                         value = 10;
6424                         }
6425                         ar[array_index] = (ats->mechanisms[c2].peer->f) * value;
6426 #if VERBOSE_ATS
6427                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",array_index, qm[c-1].name, row_index, ja[array_index], ar[array_index]);
6428 #endif
6429                         array_index++;
6430                 }
6431                 ja[array_index] = ats->stat.col_qm + c - 1;
6432                 ar[array_index] = -1;
6433
6434 #if VERBOSE_ATS
6435                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, row_index, ja[array_index], ar[array_index]);
6436 #endif
6437                 glp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
6438
6439                 array_index = 1;
6440                 row_index++;
6441         }
6442
6443         GNUNET_free_non_null (ja);
6444         GNUNET_free_non_null (ar);
6445 }
6446
6447
6448 static void ats_update_problem_cr ()
6449 {
6450
6451         int array_index;
6452         int row_index;
6453         int c, c2;
6454         double ct_max, ct_min;
6455
6456         int *ja    = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (int));
6457         double *ar = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (double));
6458
6459         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
6460         row_index = ats->stat.begin_cr;
6461
6462         for (c=0; c<available_ressources; c++)
6463         {
6464                 ct_max = ressources[c].c_max;
6465                 ct_min = ressources[c].c_min;
6466 #if VERBOSE_ATS
6467                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",row_index, ct_min, ct_max);
6468 #endif
6469                 glp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
6470
6471                 for (c2=1; c2<=ats->stat.c_mechs; c2++)
6472                 {
6473                         double value = 0;
6474
6475                         GNUNET_assert (ats->mechanisms[c2].addr != NULL);
6476                         GNUNET_assert (ats->mechanisms[c2].peer != NULL);
6477
6478                         ja[array_index] = c2;
6479                         value = ats->mechanisms[c2].addr->ressources[c].c;
6480                         ar[array_index] = value;
6481 #if VERBOSE_ATS
6482                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, row_index, ja[array_index], ar[array_index]);
6483 #endif
6484                         array_index++;
6485                 }
6486                 glp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
6487
6488                 row_index ++;
6489         }
6490
6491
6492         GNUNET_free_non_null (ja);
6493         GNUNET_free_non_null (ar);
6494 }
6495
6496
6497 #if 0
6498 static void ats_update_problem_qm_TEST ()
6499 {
6500         int row_index;
6501         int c, c2;
6502
6503         int old_ja[ats->stat.c_mechs + 2];
6504         double old_ar[ats->stat.c_mechs + 2];
6505         int c_old;
6506         int changed = 0;
6507
6508         int *ja    = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (int));
6509         double *ar = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (double));
6510 #if DEBUG_ATS
6511         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics TEST\n");
6512 #endif
6513         if (ats->stat.begin_qm >0)
6514                 row_index = ats->stat.begin_qm;
6515         else
6516                 return;
6517
6518
6519         for (c=0; c<available_quality_metrics; c++)
6520         {
6521
6522                 c_old = glp_get_mat_row (ats->prob, row_index, old_ja, old_ar);
6523
6524                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6525
6526                 for (c2=1; c2<=c_old; c2++)
6527                 {
6528                         ja[c2] = old_ja[c2];
6529                         if ((changed < 3) && (c2>2) && (old_ar[c2] != -1))
6530                         {
6531                                 ar[c2] = old_ar[c2] + 5 - changed;
6532                                 changed ++;
6533                         }
6534                         else
6535                                 ar[c2] = old_ar[c2];
6536 #if VERBOSE_ATS
6537                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: old [%i,%i]=%f  new [%i,%i]=%f\n",c2, row_index, old_ja[c2], old_ar[c2], row_index, ja[c2], ar[c2]);
6538 #endif
6539                 }
6540                 glp_set_mat_row (ats->prob, row_index, c_old, ja, ar);
6541
6542                 row_index ++;
6543         }
6544
6545         GNUNET_free_non_null (ja);
6546         GNUNET_free_non_null (ar);
6547 }
6548 #endif //END: HAVE_LIBGLPK
6549
6550 /** solve the bandwidth distribution problem
6551  * @param max_it maximum iterations
6552  * @param max_dur maximum duration in ms
6553  * @param D     weight for diversity
6554  * @param U weight for utility
6555  * @param R weight for relativity
6556  * @param v_b_min minimal bandwidth per peer
6557  * @param v_n_min minimum number of connections
6558  * @param stat result struct
6559  * @return GNUNET_SYSERR if glpk is not available, number of mechanisms used
6560  */
6561 static int ats_create_problem (double D, double U, double R, int v_b_min, int v_n_min, struct ATS_stat *stat)
6562 {
6563         ats->prob = glp_create_prob();
6564
6565         int c;
6566         int c_peers = 0;
6567         int c_mechs = 0;
6568
6569         int c_c_ressources = available_ressources;
6570         int c_q_metrics = available_quality_metrics;
6571
6572         double M = VERY_BIG_DOUBLE_VALUE;
6573         double Q[c_q_metrics+1];
6574         for (c=1; c<=c_q_metrics; c++)
6575         {
6576                 Q[c] = 1;
6577         }
6578
6579         struct NeighbourList *next = neighbours;
6580         while (next!=NULL)
6581         {
6582                 int found_addresses = GNUNET_NO;
6583                 struct ReadyList *r_next = next->plugins;
6584                 while (r_next != NULL)
6585                 {
6586                         struct ForeignAddressList * a_next = r_next->addresses;
6587                         while (a_next != NULL)
6588                         {
6589                                 c_mechs++;
6590                                 found_addresses = GNUNET_YES;
6591                                 a_next = a_next->next;
6592                         }
6593                         r_next = r_next->next;
6594                 }
6595                 if (found_addresses) c_peers++;
6596                 next = next->next;
6597         }
6598
6599         if (c_mechs==0)
6600         {
6601 #if DEBUG_ATS
6602                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No addresses for bw distribution available\n", c_peers);
6603 #endif
6604                 stat->valid = GNUNET_NO;
6605                 stat->c_peers = 0;
6606                 stat->c_mechs = 0;
6607                 return GNUNET_SYSERR;
6608         }
6609
6610         ats->mechanisms = GNUNET_malloc((1+c_mechs) * sizeof (struct ATS_mechanism));
6611         ats->peers =  GNUNET_malloc((1+c_peers) * sizeof (struct ATS_peer));
6612
6613         struct ATS_mechanism * mechanisms = ats->mechanisms;
6614         struct ATS_peer * peers = ats->peers;
6615
6616         c_mechs = 1;
6617         c_peers = 1;
6618
6619         next = neighbours;
6620         while (next!=NULL)
6621         {
6622                 int found_addresses = GNUNET_NO;
6623                 struct ReadyList *r_next = next->plugins;
6624                 while (r_next != NULL)
6625                 {
6626                         struct ForeignAddressList * a_next = r_next->addresses;
6627                         while (a_next != NULL)
6628                         {
6629                                 if (found_addresses == GNUNET_NO)
6630                                 {
6631                                         peers[c_peers].peer = next->id;
6632                                         peers[c_peers].m_head = NULL;
6633                                         peers[c_peers].m_tail = NULL;
6634                                         peers[c_peers].f = 1.0 / c_mechs;
6635                                 }
6636
6637                                 mechanisms[c_mechs].addr = a_next;
6638                                 mechanisms[c_mechs].col_index = c_mechs;
6639                                 mechanisms[c_mechs].peer = &peers[c_peers];
6640                                 mechanisms[c_mechs].next = NULL;
6641                                 mechanisms[c_mechs].plugin = r_next->plugin;
6642
6643                                 GNUNET_CONTAINER_DLL_insert_tail(peers[c_peers].m_head, peers[c_peers].m_tail, &mechanisms[c_mechs]);
6644                                 found_addresses = GNUNET_YES;
6645                                 c_mechs++;
6646
6647                                 a_next = a_next->next;
6648                         }
6649                         r_next = r_next->next;
6650                 }
6651                 if (found_addresses == GNUNET_YES)
6652                         c_peers++;
6653                 next = next->next;
6654         }
6655         c_mechs--;
6656         c_peers--;
6657
6658         if (v_n_min > c_peers)
6659                 v_n_min = c_peers;
6660
6661 #if VERBOSE_ATS
6662         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Creating problem with: %i peers, %i mechanisms, %i resource entries, %i quality metrics \n", c_peers, c_mechs, c_c_ressources, c_q_metrics);
6663 #endif
6664
6665         int size =  1 + 3 + 10 *c_mechs + c_peers + (c_q_metrics*c_mechs)+ c_q_metrics + c_c_ressources * c_mechs ;
6666         int row_index;
6667         int array_index=1;
6668         int * ia = GNUNET_malloc (size * sizeof (int));
6669         int * ja = GNUNET_malloc (size * sizeof (int));
6670         double * ar = GNUNET_malloc(size* sizeof (double));
6671
6672         glp_set_prob_name(ats->prob, "gnunet ats bandwidth distribution");
6673         glp_set_obj_dir(ats->prob, GLP_MAX);
6674
6675         /* adding columns */
6676         char * name;
6677         glp_add_cols(ats->prob, 2 * c_mechs);
6678         /* adding b_t cols */
6679         for (c=1; c <= c_mechs; c++)
6680         {
6681
6682                 GNUNET_asprintf(&name, "p_%s_b%i",GNUNET_i2s(&(mechanisms[c].peer->peer)), c);
6683                 glp_set_col_name(ats->prob, c, name);
6684                 GNUNET_free (name);
6685                 glp_set_col_bnds(ats->prob, c, GLP_LO, 0.0, 0.0);
6686                 glp_set_obj_coef(ats->prob, c, 0);
6687
6688         }
6689         /* adding n_t cols */
6690         for (c=c_mechs+1; c <= 2*c_mechs; c++)
6691         {
6692                 GNUNET_asprintf(&name, "p_%s_n%i",GNUNET_i2s(&(mechanisms[c-c_mechs].peer->peer)),(c-c_mechs));
6693                 glp_set_col_name(ats->prob, c, name);
6694                 GNUNET_free (name);
6695                 glp_set_col_bnds(ats->prob, c, GLP_DB, 0.0, 1.0);
6696                 glp_set_col_kind(ats->prob, c, GLP_IV);
6697                 glp_set_obj_coef(ats->prob, c, 0);
6698         }
6699
6700         /* feasibility constraints */
6701         /* Constraint 1: one address per peer*/
6702         row_index = 1;
6703         glp_add_rows(ats->prob, c_peers);
6704         for (c=1; c<=c_peers; c++)
6705         {
6706 #if VERBOSE_ATS
6707                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6708 #endif
6709                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 1.0, 1.0);
6710
6711                 struct ATS_mechanism *m = peers[c].m_head;
6712                 while (m!=NULL)
6713                 {
6714                         ia[array_index] = row_index;
6715                         ja[array_index] = (c_mechs + m->col_index);
6716                         ar[array_index] = 1;
6717 #if VERBOSE_ATS
6718                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6719 #endif
6720                         array_index++;
6721                         m = m->next;
6722                 }
6723                 row_index++;
6724         }
6725
6726         /* Constraint 2: only active mechanism gets bandwidth assigned */
6727         glp_add_rows(ats->prob, c_mechs);
6728         for (c=1; c<=c_mechs; c++)
6729         {
6730                 /* b_t - n_t * M <= 0 */
6731 #if VERBOSE_ATS
6732                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6733 #endif
6734                 glp_set_row_bnds(ats->prob, row_index, GLP_UP, 0.0, 0.0);
6735
6736                 ia[array_index] = row_index;
6737                 ja[array_index] = mechanisms[c].col_index;
6738                 ar[array_index] = 1;
6739 #if VERBOSE_ATS
6740                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6741 #endif
6742                 array_index++;
6743                 ia[array_index] = row_index;
6744                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6745                 ar[array_index] = -M;
6746 #if VERBOSE_ATS
6747                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6748 #endif
6749                 array_index++;
6750                 row_index ++;
6751         }
6752
6753         /* Constraint 3: minimum bandwidth*/
6754         glp_add_rows(ats->prob, c_mechs);
6755         for (c=1; c<=c_mechs; c++)
6756         {
6757                 /* b_t - n_t * b_min <= 0 */
6758 #if VERBOSE_ATS
6759                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6760 #endif
6761                 glp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
6762
6763                 ia[array_index] = row_index;
6764                 ja[array_index] = mechanisms[c].col_index;
6765                 ar[array_index] = 1;
6766 #if VERBOSE_ATS
6767                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6768 #endif
6769                 array_index++;
6770                 ia[array_index] = row_index;
6771                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6772                 ar[array_index] = -v_b_min;
6773 #if VERBOSE_ATS
6774                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6775 #endif
6776                 array_index++;
6777                 row_index ++;
6778         }
6779         int c2;
6780         /* Constraint 4: max ressource capacity */
6781         /* V cr: bt * ct_r <= cr_max
6782          * */
6783         glp_add_rows(ats->prob, available_ressources);
6784         double ct_max = VERY_BIG_DOUBLE_VALUE;
6785         double ct_min = 0.0;
6786
6787         stat->begin_cr = array_index;
6788
6789         for (c=0; c<available_ressources; c++)
6790         {
6791                 ct_max = ressources[c].c_max;
6792                 ct_min = ressources[c].c_min;
6793 #if VERBOSE_ATS
6794                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",row_index, ct_min, ct_max);
6795 #endif
6796                 glp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
6797
6798                 for (c2=1; c2<=c_mechs; c2++)
6799                 {
6800                         double value = 0;
6801                         ia[array_index] = row_index;
6802                         ja[array_index] = c2;
6803                         value = mechanisms[c2].addr->ressources[c].c;
6804                         ar[array_index] = value;
6805 #if VERBOSE_ATS
6806                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6807 #endif
6808                         array_index++;
6809                 }
6810                 row_index ++;
6811         }
6812         stat->end_cr = array_index--;
6813
6814         /* Constraint 5: min number of connections*/
6815         glp_add_rows(ats->prob, 1);
6816         for (c=1; c<=c_mechs; c++)
6817         {
6818                 // b_t - n_t * b_min >= 0
6819 #if VERBOSE_ATS
6820                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6821 #endif
6822                 glp_set_row_bnds(ats->prob, row_index, GLP_LO, v_n_min, 0.0);
6823
6824                 ia[array_index] = row_index;
6825                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6826                 ar[array_index] = 1;
6827 #if VERBOSE_ATS
6828                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6829 #endif
6830                 array_index++;
6831         }
6832         row_index ++;
6833
6834         // optimisation constraints
6835
6836         // adding columns
6837
6838         // Constraint 6: optimize for diversity
6839         int col_d;
6840         col_d = glp_add_cols(ats->prob, 1);
6841         stat->col_d = col_d;
6842         //GNUNET_assert (col_d == (2*c_mechs) + 1);
6843         glp_set_col_name(ats->prob, col_d, "d");
6844         glp_set_obj_coef(ats->prob, col_d, D);
6845         glp_set_col_bnds(ats->prob, col_d, GLP_LO, 0.0, 0.0);
6846         glp_add_rows(ats->prob, 1);
6847 #if VERBOSE_ATS
6848         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6849 #endif
6850         glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6851         for (c=1; c<=c_mechs; c++)
6852         {
6853                 // b_t - n_t * b_min >= 0
6854                 ia[array_index] = row_index;
6855                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6856                 ar[array_index] = 1;
6857 #if VERBOSE_ATS
6858                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6859 #endif
6860                 array_index++;
6861         }
6862         ia[array_index] = row_index;
6863         ja[array_index] = col_d;
6864         ar[array_index] = -1;
6865 #if VERBOSE_ATS
6866         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6867 #endif
6868         array_index++;
6869         row_index ++;
6870
6871
6872         // Constraint 7: optimize for quality
6873         int col_qm;
6874         col_qm = glp_add_cols(ats->prob, c_q_metrics);
6875         stat->col_qm = col_qm;
6876         //GNUNET_assert (col_qm == (2*c_mechs) + 3 + 1);
6877         for (c=0; c< c_q_metrics; c++)
6878         {
6879                 GNUNET_asprintf(&name, "Q_%s",qm[c].name);
6880                 glp_set_col_name(ats->prob, col_qm + c, name);
6881                 glp_set_col_bnds(ats->prob, col_qm + c, GLP_LO, 0.0, 0.0);
6882                 GNUNET_free (name);
6883                 glp_set_obj_coef(ats->prob, col_qm + c, Q[c]);
6884         }
6885     glp_add_rows(ats->prob, available_quality_metrics);
6886         stat->begin_qm = row_index;
6887         for (c=1; c <= c_q_metrics; c++)
6888         {
6889 #if VERBOSE_ATS
6890                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6891 #endif
6892                 double value = 1;
6893                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6894                 for (c2=1; c2<=c_mechs; c2++)
6895                 {
6896
6897                         ia[array_index] = row_index;
6898                         ja[array_index] = c2;
6899                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
6900                         {
6901                                 double v0 = 0, v1 = 0, v2 = 0;
6902                                 v0 = mechanisms[c2].addr->quality[c-1].values[0];
6903                                 if (v1 < 1) v0 = 0.1;
6904                                 v1 = mechanisms[c2].addr->quality[c-1].values[1];
6905                                 if (v1 < 1) v0 = 0.1;
6906                                 v2 = mechanisms[c2].addr->quality[c-1].values[2];
6907                                 if (v1 < 1) v0 = 0.1;
6908                                 value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
6909                                 value = 1;
6910                         }
6911                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
6912                         {
6913                                 double v0 = 0, v1 = 0, v2 = 0;
6914                                 v0 = mechanisms[c2].addr->quality[c-1].values[0];
6915                                 if (v0 < 1) v0 = 1;
6916                                 v1 = mechanisms[c2].addr->quality[c-1].values[1];
6917                                 if (v1 < 1) v1 = 1;
6918                                 v2 = mechanisms[c2].addr->quality[c-1].values[2];
6919                                 if (v2 < 1) v2 = 1;
6920                                 value =  (v0 + 2 * v1 + 3 * v2) / 6.0;
6921                                 if (value >= 1)
6922                                         value =  (double) 10 / value;
6923                                 else
6924                                         value = 10;
6925                         }
6926                         ar[array_index] = (mechanisms[c2].peer->f) * value ;
6927 #if VERBOSE_ATS
6928                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: %s [%i,%i]=%f \n",array_index, qm[c-1].name, ia[array_index], ja[array_index], ar[array_index]);
6929 #endif
6930                         array_index++;
6931                 }
6932
6933                 ia[array_index] = row_index;
6934                 ja[array_index] = col_qm + c - 1;
6935                 ar[array_index] = -1;
6936 #if VERBOSE_ATS
6937                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6938 #endif
6939                 array_index++;
6940                 row_index++;
6941         }
6942         stat->end_qm = row_index-1;
6943
6944         // Constraint 8: optimize bandwidth utility
6945         int col_u;
6946         col_u = glp_add_cols(ats->prob, 1);
6947         stat->col_u = col_u;
6948         //GNUNET_assert (col_u == (2*c_mechs) + 2);
6949         glp_set_col_name(ats->prob, col_u, "u");
6950         glp_set_obj_coef(ats->prob, col_u, U);
6951         glp_set_col_bnds(ats->prob, col_u, GLP_LO, 0.0, 0.0);
6952         glp_add_rows(ats->prob, 1);
6953 #if VERBOSE_ATS
6954         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6955 #endif
6956         glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6957         for (c=1; c<=c_mechs; c++)
6958         {
6959                 ia[array_index] = row_index;
6960                 ja[array_index] = c;
6961                 ar[array_index] = mechanisms[c].peer->f;
6962 #if VERBOSE_ATS
6963                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6964 #endif
6965                 array_index++;
6966         }
6967         ia[array_index] = row_index;
6968         ja[array_index] = col_u;
6969         ar[array_index] = -1;
6970 #if VERBOSE_ATS
6971         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6972 #endif
6973
6974         array_index++;
6975         row_index ++;
6976
6977         // Constraint 9: optimize relativity
6978         int col_r;
6979         col_r = glp_add_cols(ats->prob, 1);
6980         stat->col_r = col_r;
6981         //GNUNET_assert (col_r == (2*c_mechs) + 3);
6982         glp_set_col_name(ats->prob, col_r, "r");
6983         glp_set_obj_coef(ats->prob, col_r, R);
6984         glp_set_col_bnds(ats->prob, col_r, GLP_LO, 0.0, 0.0);
6985         glp_add_rows(ats->prob, c_peers);
6986         for (c=1; c<=c_peers; c++)
6987         {
6988                 glp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
6989
6990                 struct ATS_mechanism *m = peers[c].m_head;
6991                 while (m!=NULL)
6992                 {
6993                         ia[array_index] = row_index;
6994                         ja[array_index] = m->col_index;
6995                         ar[array_index] = 1 / mechanisms[c].peer->f;
6996 #if VERBOSE_ATS
6997                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6998 #endif
6999                         array_index++;
7000                         m = m->next;
7001                 }
7002                 ia[array_index] = row_index;
7003                 ja[array_index] = col_r;
7004                 ar[array_index] = -1;
7005 #if VERBOSE_ATS
7006                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
7007 #endif
7008                 array_index++;
7009
7010                 row_index++;
7011         }
7012
7013         /* Loading the matrix */
7014         glp_load_matrix(ats->prob, array_index-1, ia, ja, ar);
7015
7016         stat->c_mechs = c_mechs;
7017         stat->c_peers = c_peers;
7018         stat->solution = 0;
7019         stat->valid = GNUNET_YES;
7020
7021         /* clean up */
7022
7023         GNUNET_free (ja);
7024         GNUNET_free (ia);
7025         GNUNET_free (ar);
7026
7027         return GNUNET_OK;
7028
7029 }
7030
7031 void ats_notify_ats_data (
7032                 const struct GNUNET_PeerIdentity *peer,
7033                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data)
7034 {
7035 #if DEBUG_ATS
7036         GNUNET_log (GNUNET_ERROR_TYPE_BULK, "ATS_notify_ats_data: %s\n",GNUNET_i2s(peer));
7037 #endif
7038         ats_calculate_bandwidth_distribution();
7039 }
7040 #endif //END: HAVE_LIBGLPK
7041
7042 static void
7043 ats_calculate_bandwidth_distribution ()
7044 {
7045 #if HAVE_LIBGLPK
7046
7047         struct GNUNET_TIME_Absolute start;
7048         struct GNUNET_TIME_Relative creation;
7049         struct GNUNET_TIME_Relative solving;
7050         char *text = "unmodified";
7051
7052         struct GNUNET_TIME_Relative delta = GNUNET_TIME_absolute_get_difference (ats->last, GNUNET_TIME_absolute_get());
7053         if (delta.rel_value < ats->min_delta.rel_value)
7054         {
7055 #if DEBUG_ATS
7056                 GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Minimum time between cycles not reached\n");
7057 #endif
7058                 return;
7059         }
7060
7061         int dur = 500;
7062         if (INT_MAX < ats->max_exec_duration.rel_value)
7063                 dur = INT_MAX;
7064         else
7065                 dur = (int) ats->max_exec_duration.rel_value;
7066
7067         ats->stat.simplex_rerun_required = GNUNET_NO;
7068         start = GNUNET_TIME_absolute_get();
7069         if ((ats->stat.recreate_problem == GNUNET_YES) || (ats->prob==NULL) || (ats->stat.valid == GNUNET_NO))
7070         {
7071                 text = "new";
7072                 ats->stat.recreate_problem = GNUNET_YES;
7073                 ats_delete_problem ();
7074                 ats_create_problem (ats->D, ats->U, ats->R, ats->v_b_min, ats->v_n_min, &ats->stat);
7075 #if DEBUG_ATS
7076                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers/Addresses were modified... new problem: %i peer, %i mechs\n", ats->stat.c_peers, ats->stat.c_mechs);
7077 #endif
7078         }
7079
7080         else if ((ats->stat.recreate_problem == GNUNET_NO) && (ats->stat.modified_resources == GNUNET_YES) && (ats->stat.valid == GNUNET_YES))
7081         {
7082                 text = "modified resources";
7083                 ats_update_problem_cr();
7084         }
7085         else if ((ats->stat.recreate_problem == GNUNET_NO) && (ats->stat.modified_quality == GNUNET_YES) && (ats->stat.valid == GNUNET_YES))
7086         {
7087                 text = "modified quality";
7088                 ats_update_problem_qm();
7089                 //ats_update_problem_qm_TEST ();
7090
7091         }
7092 #if DEBUG_ATS
7093         else GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem is unmodified\n");
7094 #endif
7095
7096         creation = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
7097         start = GNUNET_TIME_absolute_get();
7098
7099         ats->stat.solution = GLP_UNDEF;
7100         if (ats->stat.valid == GNUNET_YES)
7101         {
7102                 ats_solve_problem(ats->max_iterations, ats->max_exec_duration.rel_value, ats->stat.c_peers, ats->stat.c_mechs, &ats->stat);
7103         }
7104         solving = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
7105
7106         if (ats->stat.valid == GNUNET_YES)
7107         {
7108                 int msg_type = GNUNET_ERROR_TYPE_DEBUG;
7109 #if DEBUG_ATS
7110                 msg_type = GNUNET_ERROR_TYPE_ERROR;
7111 #endif
7112                 GNUNET_log (msg_type, "MLP %s: creation time: %llu, execution time: %llu, %i mechanisms, simplex rerun: %s, solution %s\n",
7113                                 text, creation.rel_value, solving.rel_value,
7114                                 ats->stat.c_mechs,
7115                                 (ats->stat.simplex_rerun_required == GNUNET_NO) ? "NO" : "YES", (ats->stat.solution == 5) ? "OPTIMAL" : "INVALID");
7116                 ats->successful_executions ++;
7117                 GNUNET_STATISTICS_set (stats, "# ATS successful executions", ats->successful_executions, GNUNET_NO);
7118
7119                 if ((ats->stat.recreate_problem == GNUNET_YES) || (ats->prob==NULL))
7120                         GNUNET_STATISTICS_set (stats, "ATS state",ATS_NEW, GNUNET_NO);
7121                 else if ((ats->stat.modified_resources == GNUNET_YES) &&
7122                                 (ats->stat.modified_quality == GNUNET_NO))
7123                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_C_UPDATED, GNUNET_NO);
7124                 else if ((ats->stat.modified_resources == GNUNET_NO) &&
7125                                 (ats->stat.modified_quality == GNUNET_YES) &&
7126                                 (ats->stat.simplex_rerun_required == GNUNET_NO))
7127                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_Q_UPDATED, GNUNET_NO);
7128                 else if ((ats->stat.modified_resources == GNUNET_YES) &&
7129                                 (ats->stat.modified_quality == GNUNET_YES) &&
7130                                 (ats->stat.simplex_rerun_required == GNUNET_NO))
7131                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_QC_UPDATED, GNUNET_NO);
7132                 else if (ats->stat.simplex_rerun_required == GNUNET_NO)
7133                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_UNMODIFIED, GNUNET_NO);
7134         }
7135         else
7136         {
7137                 if (ats->stat.c_peers != 0)
7138                 {
7139                         ats->invalid_executions ++;
7140                         GNUNET_STATISTICS_set (stats, "# ATS invalid executions", ats->invalid_executions, GNUNET_NO);
7141                 }
7142                 else
7143                 {
7144                         GNUNET_STATISTICS_set (stats, "# ATS successful executions", ats->successful_executions, GNUNET_NO);
7145                 }
7146         }
7147
7148         GNUNET_STATISTICS_set (stats, "ATS duration", solving.rel_value + creation.rel_value, GNUNET_NO);
7149         GNUNET_STATISTICS_set (stats, "ATS mechanisms", ats->stat.c_mechs, GNUNET_NO);
7150         GNUNET_STATISTICS_set (stats, "ATS peers", ats->stat.c_peers, GNUNET_NO);
7151         GNUNET_STATISTICS_set (stats, "ATS solution", ats->stat.solution, GNUNET_NO);
7152         GNUNET_STATISTICS_set (stats, "ATS timestamp", start.abs_value, GNUNET_NO);
7153
7154         if ((ats->save_mlp == GNUNET_YES) && (ats->stat.c_mechs >= ats->dump_min_peers) && (ats->stat.c_mechs >= ats->dump_min_addr))
7155         {
7156                 char * filename;
7157                 if (ats->dump_overwrite == GNUNET_NO)
7158                 {
7159                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.mlp",
7160                         ats->stat.c_peers, ats->stat.c_mechs, text, GNUNET_TIME_absolute_get().abs_value);
7161                         glp_write_lp (ats->prob, NULL, filename);
7162                 }
7163                 else
7164                 {
7165                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.mlp",
7166                         ats->stat.c_peers, ats->stat.c_mechs );
7167                         glp_write_lp (ats->prob, NULL, filename);
7168                 }
7169                 GNUNET_free (filename);
7170         }
7171         if ((ats->save_solution == GNUNET_YES) && (ats->stat.c_mechs >= ats->dump_min_peers) && (ats->stat.c_mechs >= ats->dump_min_addr))
7172         {
7173                 char * filename;
7174                 if (ats->dump_overwrite == GNUNET_NO)
7175                 {
7176                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.sol",
7177                         ats->stat.c_peers, ats->stat.c_mechs, text, GNUNET_TIME_absolute_get().abs_value);
7178                         glp_print_sol (ats->prob, filename);
7179                 }
7180                 else
7181                 {
7182                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.sol",
7183                         ats->stat.c_peers, ats->stat.c_mechs);
7184                         glp_print_sol (ats->prob, filename);
7185                 }
7186                 GNUNET_free (filename);
7187         }
7188
7189         ats->last = GNUNET_TIME_absolute_get();
7190         ats->stat.recreate_problem = GNUNET_NO;
7191         ats->stat.modified_resources = GNUNET_NO;
7192         ats->stat.modified_quality = GNUNET_NO;
7193 #endif
7194 }
7195
7196 static void
7197 ats_schedule_calculation (void *cls,
7198                           const struct GNUNET_SCHEDULER_TaskContext *tc)
7199 {
7200         struct ATS_info *ats = (struct ATS_info *) cls;
7201         if (ats==NULL) return;
7202
7203         ats->ats_task = GNUNET_SCHEDULER_NO_TASK;
7204         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
7205             return;
7206
7207 #if DEBUG_ATS
7208         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Running scheduled calculation\n");
7209 #endif
7210
7211         ats_calculate_bandwidth_distribution (ats);
7212
7213         ats->ats_task = GNUNET_SCHEDULER_add_delayed (ats->exec_interval,
7214                                         &ats_schedule_calculation, ats);
7215 }
7216
7217 void ats_init ()
7218 {
7219         int c = 0;
7220         unsigned long long  value;
7221         char * section;
7222
7223         ats = GNUNET_malloc(sizeof (struct ATS_info));
7224
7225         ats->min_delta = ATS_MIN_INTERVAL;
7226         ats->exec_interval = ATS_EXEC_INTERVAL;
7227         ats->max_exec_duration = ATS_MAX_EXEC_DURATION;
7228         ats->max_iterations = ATS_MAX_ITERATIONS;
7229         ats->ats_task = GNUNET_SCHEDULER_NO_TASK;
7230
7231 #if !HAVE_LIBGLPK
7232         GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "GLPK not installed, ATS not active\n");
7233         return;
7234 #endif
7235
7236         ats->D = 1.0;
7237         ats->U = 1.0;
7238         ats->R = 1.0;
7239         ats->v_b_min = 64000;
7240         ats->v_n_min = 10;
7241         ats->dump_min_peers = 1;
7242         ats->dump_min_addr = 1;
7243         ats->dump_overwrite = GNUNET_NO;
7244         ats->mechanisms = NULL;
7245         ats->peers = NULL;
7246         ats->successful_executions = 0;
7247         ats->invalid_executions = 0;
7248
7249 #if HAVE_LIBGLPK
7250         ats->prob = NULL;
7251 #endif
7252
7253         /* loading cost ressources */
7254         for (c=0; c<available_ressources; c++)
7255         {
7256                 GNUNET_asprintf(&section,"%s_UP",ressources[c].cfg_param);
7257                 if (GNUNET_CONFIGURATION_have_value(cfg, "transport", section))
7258                 {
7259                         if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "transport",section, &value))
7260                         {
7261 #if DEBUG_ATS
7262                                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Found ressource cost: [%s] = %llu\n", section, value);
7263 #endif
7264                                 ressources[c].c_max = value;
7265                         }
7266                 }
7267                 GNUNET_free (section);
7268                 GNUNET_asprintf(&section,"%s_DOWN",ressources[c].cfg_param);
7269                 if (GNUNET_CONFIGURATION_have_value(cfg, "transport", section))
7270                 {
7271                         if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "transport",section, &value))
7272                         {
7273 #if DEBUG_ATS
7274                                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Found ressource cost: [%s] = %llu\n", section, value);
7275 #endif
7276                                 ressources[c].c_min = value;
7277                         }
7278                 }
7279                 GNUNET_free (section);
7280         }
7281
7282         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_MLP"))
7283                 ats->save_mlp = GNUNET_CONFIGURATION_get_value_yesno (cfg, "transport","DUMP_MLP");
7284
7285         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_SOLUTION"))
7286                 ats->save_solution = GNUNET_CONFIGURATION_get_value_yesno (cfg, "transport","DUMP_SOLUTION");
7287         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_OVERWRITE"))
7288                 ats->dump_overwrite = GNUNET_CONFIGURATION_get_value_yesno (cfg, "transport","DUMP_OVERWRITE");
7289         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_MIN_PEERS"))
7290         {
7291                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","DUMP_MIN_PEERS", &value);
7292                 ats->dump_min_peers= value;
7293         }
7294         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_MIN_ADDRS"))
7295         {
7296                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","DUMP_MIN_ADDRS", &value);
7297                 ats->dump_min_addr= value;
7298         }
7299         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_OVERWRITE"))
7300         {
7301                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","DUMP_OVERWRITE", &value);
7302                 ats->min_delta.rel_value = value;
7303         }
7304
7305         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "ATS_MIN_INTERVAL"))
7306         {
7307                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","ATS_MIN_INTERVAL", &value);
7308                 ats->min_delta.rel_value = value;
7309         }
7310
7311         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "ATS_EXEC_INTERVAL"))
7312         {
7313                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","ATS_EXEC_INTERVAL", &value);
7314                 ats->exec_interval.rel_value = value;
7315         }
7316         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "ATS_MIN_INTERVAL"))
7317         {
7318                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","ATS_MIN_INTERVAL", &value);
7319                 ats->min_delta.rel_value = value;
7320         }
7321
7322         ats->ats_task = GNUNET_SCHEDULER_add_now(&ats_schedule_calculation, ats);
7323 }
7324
7325
7326 static void ats_shutdown ()
7327 {
7328 #if DEBUG_ATS
7329         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ats_destroy\n");
7330 #endif
7331         if (ats->ats_task != GNUNET_SCHEDULER_NO_TASK)
7332                 GNUNET_SCHEDULER_cancel(ats->ats_task);
7333         ats->ats_task = GNUNET_SCHEDULER_NO_TASK;
7334
7335 #if HAVE_LIBGLPK
7336         ats_delete_problem ();
7337         glp_free_env();
7338 #endif
7339         GNUNET_free (ats);
7340 }
7341
7342
7343 void ats_notify_peer_connect (
7344                 const struct GNUNET_PeerIdentity *peer,
7345                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data, int ats_count)
7346 {
7347 #if DEBUG_ATS
7348         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ats_notify_peer_connect: %s\n",GNUNET_i2s(peer));
7349 #endif
7350         //update_addr_ats();
7351         ats->stat.recreate_problem = GNUNET_YES;
7352         ats_calculate_bandwidth_distribution(ats);
7353 }
7354
7355 void ats_notify_peer_disconnect (
7356                 const struct GNUNET_PeerIdentity *peer)
7357 {
7358 #if DEBUG_ATS
7359         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ats_notify_peer_disconnect: %s\n",GNUNET_i2s(peer));
7360 #endif
7361         ats->stat.recreate_problem = GNUNET_YES;
7362         ats_calculate_bandwidth_distribution (ats);
7363 }
7364
7365 struct ForeignAddressList * ats_get_preferred_address (
7366                 struct NeighbourList *n)
7367 {
7368 #if DEBUG_ATS
7369         //GNUNET_log (GNUNET_ERROR_TYPE_BULK, "ats_get_prefered_transport for peer: %s\n",GNUNET_i2s(&n->id));
7370 #endif
7371         struct ReadyList *next = n->plugins;
7372         while (next != NULL)
7373         {
7374 #if DEBUG_ATS
7375                 //GNUNET_log (GNUNET_ERROR_TYPE_BULK, "plugin: %s %i\n",next->plugin->short_name,strcmp(next->plugin->short_name,"unix"));
7376 #endif
7377                 next = next->next;
7378         }
7379         return find_ready_address(n);
7380 }
7381
7382 /**
7383  * Initiate transport service.
7384  *
7385  * @param cls closure
7386  * @param server the initialized server
7387  * @param c configuration to use
7388  */
7389 static void
7390 run (void *cls,
7391      struct GNUNET_SERVER_Handle *server,
7392      const struct GNUNET_CONFIGURATION_Handle *c)
7393 {
7394   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
7395     {&handle_start, NULL,
7396      GNUNET_MESSAGE_TYPE_TRANSPORT_START, sizeof (struct StartMessage)},
7397     {&handle_hello, NULL,
7398      GNUNET_MESSAGE_TYPE_HELLO, 0},
7399     {&handle_send, NULL,
7400      GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0},
7401     {&handle_request_connect, NULL,
7402      GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT, sizeof(struct TransportRequestConnectMessage)},
7403     {&handle_set_quota, NULL,
7404      GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)},
7405     {&handle_address_lookup, NULL,
7406      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP,
7407      0},
7408     {&handle_blacklist_init, NULL,
7409      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, sizeof (struct GNUNET_MessageHeader)},
7410     {&handle_blacklist_reply, NULL,
7411      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, sizeof (struct BlacklistMessage)},
7412     {NULL, NULL, 0, 0}
7413   };
7414   char *plugs;
7415   char *pos;
7416   int no_transports;
7417   unsigned long long tneigh;
7418   char *keyfile;
7419
7420   cfg = c;
7421   stats = GNUNET_STATISTICS_create ("transport", cfg);
7422   validation_map = GNUNET_CONTAINER_multihashmap_create (64);
7423   /* parse configuration */
7424   if ((GNUNET_OK !=
7425        GNUNET_CONFIGURATION_get_value_number (c,
7426                                               "TRANSPORT",
7427                                               "NEIGHBOUR_LIMIT",
7428                                               &tneigh)) ||
7429       (GNUNET_OK !=
7430        GNUNET_CONFIGURATION_get_value_filename (c,
7431                                                 "GNUNETD",
7432                                                 "HOSTKEY", &keyfile)))
7433     {
7434       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7435                   _
7436                   ("Transport service is lacking key configuration settings.  Exiting.\n"));
7437       GNUNET_SCHEDULER_shutdown ();
7438       if (stats != NULL)
7439         {
7440           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
7441           stats = NULL;
7442         }
7443       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
7444       validation_map = NULL;
7445       return;
7446     }
7447
7448   max_connect_per_transport = (uint32_t) tneigh;
7449   peerinfo = GNUNET_PEERINFO_connect (cfg);
7450   if (peerinfo == NULL)
7451     {
7452       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7453                   _("Could not access PEERINFO service.  Exiting.\n"));
7454       GNUNET_SCHEDULER_shutdown ();
7455       if (stats != NULL)
7456         {
7457           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
7458           stats = NULL;
7459         }
7460       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
7461       validation_map = NULL;
7462       GNUNET_free (keyfile);
7463       return;
7464     }
7465   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
7466   GNUNET_free (keyfile);
7467   if (my_private_key == NULL)
7468     {
7469       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7470                   _
7471                   ("Transport service could not access hostkey.  Exiting.\n"));
7472       GNUNET_SCHEDULER_shutdown ();
7473       if (stats != NULL)
7474         {
7475           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
7476           stats = NULL;
7477         }
7478       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
7479       validation_map = NULL;
7480       return;
7481     }
7482   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
7483   GNUNET_CRYPTO_hash (&my_public_key,
7484                       sizeof (my_public_key), &my_identity.hashPubKey);
7485   /* setup notification */
7486   GNUNET_SERVER_disconnect_notify (server,
7487                                    &client_disconnect_notification, NULL);
7488   /* load plugins... */
7489   no_transports = 1;
7490   if (GNUNET_OK ==
7491       GNUNET_CONFIGURATION_get_value_string (c,
7492                                              "TRANSPORT", "PLUGINS", &plugs))
7493     {
7494       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
7495                   _("Starting transport plugins `%s'\n"), plugs);
7496       pos = strtok (plugs, " ");
7497       while (pos != NULL)
7498         {
7499           start_transport (server, pos);
7500           no_transports = 0;
7501           pos = strtok (NULL, " ");
7502         }
7503       GNUNET_free (plugs);
7504     }
7505   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
7506                                 &shutdown_task, NULL);
7507   if (no_transports)
7508     refresh_hello ();
7509
7510   ats_init();
7511
7512 #if DEBUG_TRANSPORT
7513   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport service ready.\n"));
7514 #endif
7515   /* If we have a blacklist file, read from it */
7516   read_blacklist_file(cfg);
7517   /* process client requests */
7518   GNUNET_SERVER_add_handlers (server, handlers);
7519 }
7520
7521
7522 /**
7523  * The main function for the transport service.
7524  *
7525  * @param argc number of arguments from the command line
7526  * @param argv command line arguments
7527  * @return 0 ok, 1 on error
7528  */
7529 int
7530 main (int argc, char *const *argv)
7531 {
7532   a2s (NULL, NULL, 0); /* make compiler happy */
7533   return (GNUNET_OK ==
7534           GNUNET_SERVICE_run (argc,
7535                               argv,
7536                               "transport",
7537                               GNUNET_SERVICE_OPTION_NONE,
7538                               &run, NULL)) ? 0 : 1;
7539 }
7540
7541 /* end of gnunet-service-transport.c */