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                   // Do not disconnect if: an address is connected or an inbound address exists
4921               if ((GNUNET_YES == peer_addresses->connected) || (peer_addresses->addrlen == 0))
4922                 {
4923 #if DEBUG_TRANSPORT
4924                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4925                               "NOT Disconnecting from `%4s', still have live addresses!\n",
4926                               GNUNET_i2s (&n->id));
4927 #endif
4928                   return;             /* still connected */
4929                 }
4930               peer_addresses = peer_addresses->next;
4931             }
4932           rpos = rpos->next;
4933         }
4934     }
4935 #if DEBUG_TRANSPORT
4936   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
4937               "Disconnecting from `%4s'\n",
4938               GNUNET_i2s (&n->id));
4939 #endif
4940   /* remove n from neighbours list */
4941   nprev = NULL;
4942   npos = neighbours;
4943   while ((npos != NULL) && (npos != n))
4944     {
4945       nprev = npos;
4946       npos = npos->next;
4947     }
4948   GNUNET_assert (npos != NULL);
4949   if (nprev == NULL)
4950     neighbours = n->next;
4951   else
4952     nprev->next = n->next;
4953
4954   /* notify all clients about disconnect */
4955   if (GNUNET_YES == n->received_pong)
4956     notify_clients_disconnect (&n->id);
4957
4958   /* clean up all plugins, cancel connections and pending transmissions */
4959   while (NULL != (rpos = n->plugins))
4960     {
4961       n->plugins = rpos->next;
4962       rpos->plugin->api->disconnect (rpos->plugin->api->cls, &n->id);
4963       while (rpos->addresses != NULL)
4964         {
4965           peer_pos = rpos->addresses;
4966           rpos->addresses = peer_pos->next;
4967           if (peer_pos->connected == GNUNET_YES)
4968             GNUNET_STATISTICS_update (stats,
4969                                       gettext_noop ("# connected addresses"),
4970                                       -1,
4971                                       GNUNET_NO);
4972           if (GNUNET_YES == peer_pos->validated)
4973             GNUNET_STATISTICS_update (stats,
4974                                       gettext_noop ("# peer addresses considered valid"),
4975                                       -1,
4976                                       GNUNET_NO);
4977           if (GNUNET_SCHEDULER_NO_TASK != peer_pos->revalidate_task)
4978             {
4979               GNUNET_SCHEDULER_cancel (peer_pos->revalidate_task);
4980               peer_pos->revalidate_task = GNUNET_SCHEDULER_NO_TASK;
4981             }
4982           GNUNET_free(peer_pos->ressources);
4983           peer_pos->ressources = NULL;
4984           GNUNET_free(peer_pos->quality);
4985           peer_pos->ressources = NULL;
4986           GNUNET_free(peer_pos);
4987           ats->stat.recreate_problem = GNUNET_YES;
4988         }
4989       GNUNET_free (rpos);
4990     }
4991
4992   /* free all messages on the queue */
4993   while (NULL != (mq = n->messages_head))
4994     {
4995       GNUNET_STATISTICS_update (stats,
4996                                 gettext_noop ("# bytes in message queue for other peers"),
4997                                 - (int64_t) mq->message_buf_size,
4998                                 GNUNET_NO);
4999       GNUNET_STATISTICS_update (stats,
5000                                 gettext_noop ("# bytes discarded due to disconnect"),
5001                                 mq->message_buf_size,
5002                                 GNUNET_NO);
5003       GNUNET_CONTAINER_DLL_remove (n->messages_head,
5004                                    n->messages_tail,
5005                                    mq);
5006       GNUNET_assert (0 == memcmp(&mq->neighbour_id,
5007                                  &n->id,
5008                                  sizeof(struct GNUNET_PeerIdentity)));
5009       GNUNET_free (mq);
5010     }
5011   if (n->timeout_task != GNUNET_SCHEDULER_NO_TASK)
5012     {
5013       GNUNET_SCHEDULER_cancel (n->timeout_task);
5014       n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
5015     }
5016   if (n->retry_task != GNUNET_SCHEDULER_NO_TASK)
5017     {
5018       GNUNET_SCHEDULER_cancel (n->retry_task);
5019       n->retry_task = GNUNET_SCHEDULER_NO_TASK;
5020     }
5021   if (n->piter != NULL)
5022     {
5023       GNUNET_PEERINFO_iterate_cancel (n->piter);
5024       GNUNET_STATISTICS_update (stats,
5025                                 gettext_noop ("# outstanding peerinfo iterate requests"),
5026                                 -1,
5027                                 GNUNET_NO);
5028       n->piter = NULL;
5029     }
5030   /* finally, free n itself */
5031   GNUNET_STATISTICS_update (stats,
5032                             gettext_noop ("# active neighbours"),
5033                             -1,
5034                             GNUNET_NO);
5035   GNUNET_free_non_null (n->pre_connect_message_buffer);
5036   GNUNET_free (n);
5037 }
5038
5039
5040 /**
5041  * We have received a PING message from someone.  Need to send a PONG message
5042  * in response to the peer by any means necessary.
5043  */
5044 static int
5045 handle_ping(void *cls, const struct GNUNET_MessageHeader *message,
5046             const struct GNUNET_PeerIdentity *peer,
5047             struct Session *session,
5048             const char *sender_address,
5049             uint16_t sender_address_len)
5050 {
5051   struct TransportPlugin *plugin = cls;
5052   struct SessionHeader *session_header = (struct SessionHeader*) session;
5053   struct TransportPingMessage *ping;
5054   struct TransportPongMessage *pong;
5055   struct NeighbourList *n;
5056   struct ReadyList *rl;
5057   struct ForeignAddressList *fal;
5058   struct OwnAddressList *oal;
5059   const char *addr;
5060   size_t alen;
5061   size_t slen;
5062
5063   if (ntohs (message->size) < sizeof (struct TransportPingMessage))
5064     {
5065       GNUNET_break_op (0);
5066       return GNUNET_SYSERR;
5067     }
5068
5069   ping = (struct TransportPingMessage *) message;
5070   if (0 != memcmp (&ping->target,
5071                    plugin->env.my_identity,
5072                    sizeof (struct GNUNET_PeerIdentity)))
5073     {
5074 #if DEBUG_TRANSPORT
5075       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5076                   _("Received `%s' message from `%s' destined for `%s' which is not me!\n"),
5077                   "PING",
5078                   (sender_address != NULL)
5079                   ? a2s (plugin->short_name,
5080                          (const struct sockaddr *)sender_address,
5081                          sender_address_len)
5082                   : "<inbound>",
5083                   GNUNET_i2s (&ping->target));
5084 #endif
5085       return GNUNET_SYSERR;
5086     }
5087 #if DEBUG_PING_PONG
5088   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
5089               "Processing `%s' from `%s'\n",
5090               "PING",
5091               (sender_address != NULL)
5092               ? a2s (plugin->short_name,
5093                      (const struct sockaddr *)sender_address,
5094                      sender_address_len)
5095               : "<inbound>");
5096 #endif
5097   GNUNET_STATISTICS_update (stats,
5098                             gettext_noop ("# PING messages received"),
5099                             1,
5100                             GNUNET_NO);
5101   addr = (const char*) &ping[1];
5102   alen = ntohs (message->size) - sizeof (struct TransportPingMessage);
5103   slen = strlen (plugin->short_name) + 1;
5104   if (alen == 0)
5105     {
5106       /* peer wants to confirm that we have an outbound connection to him */
5107       if (session == NULL)
5108         {
5109           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5110                       _("Refusing to create PONG since I do not have a session with `%s'.\n"),
5111                       GNUNET_i2s (peer));
5112           return GNUNET_SYSERR;
5113         }
5114       pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + sender_address_len + slen);
5115       pong->header.size = htons (sizeof (struct TransportPongMessage) + sender_address_len + slen);
5116       pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
5117       pong->purpose.size =
5118         htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
5119                sizeof (uint32_t) +
5120                sizeof (struct GNUNET_TIME_AbsoluteNBO) +
5121                sizeof (struct GNUNET_PeerIdentity) + sender_address_len + slen);
5122       pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_USING);
5123       pong->challenge = ping->challenge;
5124       pong->addrlen = htonl(sender_address_len + slen);
5125       memcpy(&pong->pid,
5126              peer,
5127              sizeof(struct GNUNET_PeerIdentity));
5128       memcpy (&pong[1],
5129               plugin->short_name,
5130               slen);
5131       if ((sender_address!=NULL) && (sender_address_len > 0))
5132                   memcpy (&((char*)&pong[1])[slen],
5133                           sender_address,
5134                           sender_address_len);
5135       if (GNUNET_TIME_absolute_get_remaining (session_header->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4)
5136         {
5137           /* create / update cached sig */
5138 #if DEBUG_TRANSPORT
5139           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5140                       "Creating PONG signature to indicate active connection.\n");
5141 #endif
5142           session_header->pong_sig_expires = GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME);
5143           pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
5144           GNUNET_assert (GNUNET_OK ==
5145                          GNUNET_CRYPTO_rsa_sign (my_private_key,
5146                                                  &pong->purpose,
5147                                                  &session_header->pong_signature));
5148         }
5149       else
5150         {
5151           pong->expiration = GNUNET_TIME_absolute_hton (session_header->pong_sig_expires);
5152         }
5153       memcpy (&pong->signature,
5154               &session_header->pong_signature,
5155               sizeof (struct GNUNET_CRYPTO_RsaSignature));
5156
5157
5158     }
5159   else
5160     {
5161       /* peer wants to confirm that this is one of our addresses */
5162       addr += slen;
5163       alen -= slen;
5164       if (GNUNET_OK !=
5165           plugin->api->check_address (plugin->api->cls,
5166                                       addr,
5167                                       alen))
5168         {
5169           GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5170                       _("Not confirming PING with address `%s' since I cannot confirm having this address.\n"),
5171                       a2s (plugin->short_name,
5172                            addr,
5173                            alen));
5174           return GNUNET_NO;
5175         }
5176       oal = plugin->addresses;
5177       while (NULL != oal)
5178         {
5179           if ( (oal->addrlen == alen) &&
5180                (0 == memcmp (addr,
5181                              &oal[1],
5182                              alen)) )
5183             break;
5184           oal = oal->next;
5185         }
5186       pong = GNUNET_malloc (sizeof (struct TransportPongMessage) + alen + slen);
5187       pong->header.size = htons (sizeof (struct TransportPongMessage) + alen + slen);
5188       pong->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_PONG);
5189       pong->purpose.size =
5190         htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
5191                sizeof (uint32_t) +
5192                sizeof (struct GNUNET_TIME_AbsoluteNBO) +
5193                sizeof (struct GNUNET_PeerIdentity) + alen + slen);
5194       pong->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_PONG_OWN);
5195       pong->challenge = ping->challenge;
5196       pong->addrlen = htonl(alen + slen);
5197       memcpy(&pong->pid,
5198              &my_identity,
5199              sizeof(struct GNUNET_PeerIdentity));
5200       memcpy (&pong[1], plugin->short_name, slen);
5201       memcpy (&((char*)&pong[1])[slen], addr, alen);
5202       if ( (oal != NULL) &&
5203            (GNUNET_TIME_absolute_get_remaining (oal->pong_sig_expires).rel_value < PONG_SIGNATURE_LIFETIME.rel_value / 4) )
5204         {
5205           /* create / update cached sig */
5206 #if DEBUG_TRANSPORT
5207           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5208                       "Creating PONG signature to indicate ownership.\n");
5209 #endif
5210           oal->pong_sig_expires = GNUNET_TIME_absolute_min (oal->expires,
5211                                                             GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
5212           pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
5213           GNUNET_assert (GNUNET_OK ==
5214                          GNUNET_CRYPTO_rsa_sign (my_private_key,
5215                                                  &pong->purpose,
5216                                                  &oal->pong_signature));
5217           memcpy (&pong->signature,
5218                   &oal->pong_signature,
5219                   sizeof (struct GNUNET_CRYPTO_RsaSignature));
5220         }
5221       else if (oal == NULL)
5222         {
5223           /* not using cache (typically DV-only) */
5224           pong->expiration = GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (PONG_SIGNATURE_LIFETIME));
5225           GNUNET_assert (GNUNET_OK ==
5226                          GNUNET_CRYPTO_rsa_sign (my_private_key,
5227                                                  &pong->purpose,
5228                                                  &pong->signature));
5229         }
5230       else
5231         {
5232           /* can used cached version */
5233           pong->expiration = GNUNET_TIME_absolute_hton (oal->pong_sig_expires);
5234           memcpy (&pong->signature,
5235                   &oal->pong_signature,
5236                   sizeof (struct GNUNET_CRYPTO_RsaSignature));
5237         }
5238     }
5239   n = find_neighbour(peer);
5240   GNUNET_assert (n != NULL);
5241   /* first try reliable response transmission */
5242   rl = n->plugins;
5243   while (rl != NULL)
5244     {
5245       fal = rl->addresses;
5246       while (fal != NULL)
5247         {
5248           if (-1 != rl->plugin->api->send (rl->plugin->api->cls,
5249                                            peer,
5250                                            (const char*) pong,
5251                                            ntohs (pong->header.size),
5252                                            TRANSPORT_PONG_PRIORITY,
5253                                            HELLO_VERIFICATION_TIMEOUT,
5254                                            fal->session,
5255                                            fal->addr,
5256                                            fal->addrlen,
5257                                            GNUNET_SYSERR,
5258                                            NULL, NULL))
5259             {
5260               /* done! */
5261               GNUNET_STATISTICS_update (stats,
5262                                         gettext_noop ("# PONGs unicast via reliable transport"),
5263                                         1,
5264                                         GNUNET_NO);
5265               GNUNET_free (pong);
5266               return GNUNET_OK;
5267             }
5268           fal = fal->next;
5269         }
5270       rl = rl->next;
5271     }
5272   /* no reliable method found, do multicast */
5273   GNUNET_STATISTICS_update (stats,
5274                             gettext_noop ("# PONGs multicast to all available addresses"),
5275                             1,
5276                             GNUNET_NO);
5277   rl = n->plugins;
5278   while (rl != NULL)
5279     {
5280       fal = rl->addresses;
5281       while (fal != NULL)
5282         {
5283           transmit_to_peer(NULL, fal,
5284                            TRANSPORT_PONG_PRIORITY,
5285                            HELLO_VERIFICATION_TIMEOUT,
5286                            (const char *)pong,
5287                            ntohs(pong->header.size),
5288                            GNUNET_YES,
5289                            n);
5290           fal = fal->next;
5291         }
5292       rl = rl->next;
5293     }
5294   GNUNET_free(pong);
5295   return GNUNET_OK;
5296 }
5297
5298
5299
5300
5301
5302 /**
5303  * Function called by the plugin for each received message.
5304  * Update data volumes, possibly notify plugins about
5305  * reducing the rate at which they read from the socket
5306  * and generally forward to our receive callback.
5307  *
5308  * @param cls the "struct TransportPlugin *" we gave to the plugin
5309  * @param peer (claimed) identity of the other peer
5310  * @param message the message, NULL if we only care about
5311  *                learning about the delay until we should receive again
5312  * @param ats_data information for automatic transport selection
5313  * @param ats_count number of elements in ats not including 0-terminator
5314  * @param session identifier used for this session (can be NULL)
5315  * @param sender_address binary address of the sender (if observed)
5316  * @param sender_address_len number of bytes in sender_address
5317  * @return how long in ms the plugin should wait until receiving more data
5318  *         (plugins that do not support this, can ignore the return value)
5319  */
5320 static struct GNUNET_TIME_Relative
5321 plugin_env_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
5322                     const struct GNUNET_MessageHeader *message,
5323                     const struct GNUNET_TRANSPORT_ATS_Information *ats_data,
5324                     uint32_t ats_count,
5325                     struct Session *session,
5326                     const char *sender_address,
5327                     uint16_t sender_address_len)
5328 {
5329   struct TransportPlugin *plugin = cls;
5330   struct ReadyList *service_context;
5331   struct ForeignAddressList *peer_address;
5332   uint16_t msize;
5333   struct NeighbourList *n;
5334   struct GNUNET_TIME_Relative ret;
5335   if (is_blacklisted (peer, plugin))
5336     return GNUNET_TIME_UNIT_FOREVER_REL;
5337   uint32_t distance;
5338   int c;
5339
5340   n = find_neighbour (peer);
5341   if (n == NULL)
5342     n = setup_new_neighbour (peer, GNUNET_YES);
5343   service_context = n->plugins;
5344   while ((service_context != NULL) && (plugin != service_context->plugin))
5345     service_context = service_context->next;
5346   GNUNET_assert ((plugin->api->send == NULL) || (service_context != NULL));
5347   peer_address = NULL;
5348   distance = 1;
5349
5350   for (c=0; c<ats_count; c++)
5351   {
5352           if (ntohl(ats_data[c].type) == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
5353           {
5354                   distance = ntohl(ats_data[c].value);
5355           }
5356   }
5357
5358   /* notify ATS about incoming data */
5359   //ats_notify_ats_data(peer, ats_data);
5360
5361
5362   if (message != NULL)
5363     {
5364       if ( (session != NULL) ||
5365            (sender_address != NULL) )
5366         peer_address = add_peer_address (n,
5367                                          plugin->short_name,
5368                                          session,
5369                                          sender_address,
5370                                          sender_address_len);
5371       if (peer_address != NULL)
5372         {
5373
5374       update_addr_ats(peer_address, ats_data, ats_count);
5375       update_addr_value(peer_address, distance, GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
5376
5377       peer_address->distance = distance;
5378           if (GNUNET_YES == peer_address->validated)
5379             mark_address_connected (peer_address);
5380           peer_address->timeout
5381             =
5382             GNUNET_TIME_relative_to_absolute
5383             (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
5384           schedule_next_ping (peer_address);
5385         }
5386       /* update traffic received amount ... */
5387       msize = ntohs (message->size);
5388
5389       GNUNET_STATISTICS_update (stats,
5390                                 gettext_noop ("# bytes received from other peers"),
5391                                 msize,
5392                                 GNUNET_NO);
5393       n->distance = distance;
5394       n->peer_timeout =
5395         GNUNET_TIME_relative_to_absolute
5396         (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
5397       GNUNET_SCHEDULER_cancel (n->timeout_task);
5398       n->timeout_task =
5399         GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
5400                                       &neighbour_timeout_task, n);
5401       if (n->quota_violation_count > QUOTA_VIOLATION_DROP_THRESHOLD)
5402         {
5403           /* dropping message due to frequent inbound volume violations! */
5404           GNUNET_log (GNUNET_ERROR_TYPE_WARNING |
5405                       GNUNET_ERROR_TYPE_BULK,
5406                       _
5407                       ("Dropping incoming message due to repeated bandwidth quota (%u b/s) violations (total of %u).\n"),
5408                       n->in_tracker.available_bytes_per_s__,
5409                       n->quota_violation_count);
5410           GNUNET_STATISTICS_update (stats,
5411                                     gettext_noop ("# bandwidth quota violations by other peers"),
5412                                     1,
5413                                     GNUNET_NO);
5414           return GNUNET_CONSTANTS_QUOTA_VIOLATION_TIMEOUT;
5415         }
5416     if ((ntohs(message->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_ATS) &&
5417         (ntohs(message->size) == (sizeof (struct GNUNET_MessageHeader) + sizeof (uint32_t))))
5418     {
5419         uint32_t value =  ntohl(*((uint32_t *) &message[1]));
5420         //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GNUNET_MESSAGE_TYPE_TRANSPORT_ATS: %i \n", value);
5421         /* Force ressource and quality update */
5422         if (value == 4)
5423         {
5424                 ats->stat.modified_resources = GNUNET_YES;
5425                 ats->stat.modified_quality = GNUNET_YES;
5426         }
5427         /* Force cost update */
5428         if (value == 3)
5429                 ats->stat.modified_resources = GNUNET_YES;
5430         /* Force quality update */
5431         if (value == 2)
5432                 ats->stat.modified_quality = GNUNET_YES;
5433         /* Force full rebuild */
5434         if (value == 1)
5435                 ats->stat.recreate_problem = GNUNET_YES;
5436     }
5437
5438 #if DEBUG_PING_PONG
5439           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5440                       "Received message of type %u and size %u from `%4s', sending to all clients.\n",
5441                       ntohs (message->type),
5442                       ntohs (message->size),
5443                       GNUNET_i2s (peer));
5444 #endif
5445       switch (ntohs (message->type))
5446         {
5447         case GNUNET_MESSAGE_TYPE_HELLO:
5448           GNUNET_STATISTICS_update (stats,
5449                                     gettext_noop ("# HELLO messages received from other peers"),
5450                                     1,
5451                                     GNUNET_NO);
5452           process_hello (plugin, message);
5453           break;
5454         case GNUNET_MESSAGE_TYPE_TRANSPORT_PING:
5455           handle_ping (plugin, message, peer, session, sender_address, sender_address_len);
5456           break;
5457         case GNUNET_MESSAGE_TYPE_TRANSPORT_PONG:
5458           handle_pong (plugin, message, peer, sender_address, sender_address_len);
5459           break;
5460         case GNUNET_MESSAGE_TYPE_TRANSPORT_ATS:
5461           break;
5462         default:
5463           handle_payload_message (message, n);
5464           break;
5465         }
5466     }
5467   ret = GNUNET_BANDWIDTH_tracker_get_delay (&n->in_tracker, 0);
5468   if (ret.rel_value > 0)
5469     {
5470 #if DEBUG_TRANSPORT
5471       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5472                   "Throttling read (%llu bytes excess at %u b/s), waiting %llums before reading more.\n",
5473                   (unsigned long long) n->in_tracker.consumption_since_last_update__,
5474                   (unsigned int) n->in_tracker.available_bytes_per_s__,
5475                   (unsigned long long) ret.rel_value);
5476 #endif
5477       GNUNET_STATISTICS_update (stats,
5478                                 gettext_noop ("# ms throttling suggested"),
5479                                 (int64_t) ret.rel_value,
5480                                 GNUNET_NO);
5481     }
5482   return ret;
5483 }
5484
5485 /**
5486  * Handle START-message.  This is the first message sent to us
5487  * by any client which causes us to add it to our list.
5488  *
5489  * @param cls closure (always NULL)
5490  * @param client identification of the client
5491  * @param message the actual message
5492  */
5493 static void
5494 handle_start (void *cls,
5495               struct GNUNET_SERVER_Client *client,
5496               const struct GNUNET_MessageHeader *message)
5497 {
5498   const struct StartMessage *start;
5499   struct TransportClient *c;
5500   struct ConnectInfoMessage * cim;
5501   struct NeighbourList *n;
5502   uint32_t ats_count;
5503   size_t size;
5504
5505   start = (const struct StartMessage*) message;
5506 #if DEBUG_TRANSPORT
5507   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5508               "Received `%s' request from client\n", "START");
5509 #endif
5510   c = clients;
5511   while (c != NULL)
5512     {
5513       if (c->client == client)
5514         {
5515           /* client already on our list! */
5516           GNUNET_break (0);
5517           GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5518           return;
5519         }
5520       c = c->next;
5521     }
5522   if ( (GNUNET_NO != ntohl (start->do_check)) &&
5523        (0 != memcmp (&start->self,
5524                      &my_identity,
5525                      sizeof (struct GNUNET_PeerIdentity))) )
5526     {
5527       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5528                   _("Rejecting control connection from peer `%s', which is not me!\n"),
5529                   GNUNET_i2s (&start->self));
5530       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5531       return;
5532     }
5533   c = GNUNET_malloc (sizeof (struct TransportClient));
5534   c->next = clients;
5535   clients = c;
5536   c->client = client;
5537   if (our_hello != NULL)
5538   {
5539 #if DEBUG_TRANSPORT
5540       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5541                   "Sending our own `%s' to new client\n", "HELLO");
5542 #endif
5543       transmit_to_client (c,
5544                           (const struct GNUNET_MessageHeader *) our_hello,
5545                           GNUNET_NO);
5546       /* tell new client about all existing connections */
5547       ats_count = 2;
5548       size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
5549       if (size > GNUNET_SERVER_MAX_MESSAGE_SIZE)
5550       {
5551           GNUNET_break(0);
5552       }
5553       cim = GNUNET_malloc (size);
5554       cim->header.size = htons (size);
5555       cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
5556       cim->ats_count = htonl(ats_count);
5557       (&(cim->ats))[2].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
5558       (&(cim->ats))[2].value = htonl (0);
5559       n = neighbours;
5560       while (n != NULL)
5561           {
5562                   if (GNUNET_YES == n->received_pong)
5563                   {
5564                           (&(cim->ats))[0].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE);
5565                           (&(cim->ats))[0].value = htonl (n->distance);
5566                           (&(cim->ats))[1].type = htonl (GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY);
5567                           (&(cim->ats))[1].value = htonl ((uint32_t) n->latency.rel_value);
5568                           cim->id = n->id;
5569                           transmit_to_client (c, &cim->header, GNUNET_NO);
5570                   }
5571             n = n->next;
5572       }
5573       GNUNET_free (cim);
5574   }
5575   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5576 }
5577
5578
5579 /**
5580  * Handle HELLO-message.
5581  *
5582  * @param cls closure (always NULL)
5583  * @param client identification of the client
5584  * @param message the actual message
5585  */
5586 static void
5587 handle_hello (void *cls,
5588               struct GNUNET_SERVER_Client *client,
5589               const struct GNUNET_MessageHeader *message)
5590 {
5591   int ret;
5592
5593   GNUNET_STATISTICS_update (stats,
5594                             gettext_noop ("# HELLOs received from clients"),
5595                             1,
5596                             GNUNET_NO);
5597   ret = process_hello (NULL, message);
5598   GNUNET_SERVER_receive_done (client, ret);
5599 }
5600
5601
5602 /**
5603  * Closure for 'transmit_client_message'; followed by
5604  * 'msize' bytes of the actual message.
5605  */
5606 struct TransmitClientMessageContext
5607 {
5608   /**
5609    * Client on whom's behalf we are sending.
5610    */
5611   struct GNUNET_SERVER_Client *client;
5612
5613   /**
5614    * Timeout for the transmission.
5615    */
5616   struct GNUNET_TIME_Absolute timeout;
5617
5618   /**
5619    * Message priority.
5620    */
5621   uint32_t priority;
5622
5623   /**
5624    * Size of the message in bytes.
5625    */
5626   uint16_t msize;
5627 };
5628
5629
5630 /**
5631  * Schedule transmission of a message we got from a client to a peer.
5632  *
5633  * @param cls the 'struct TransmitClientMessageContext*'
5634  * @param n destination, or NULL on error (in that case, drop the message)
5635  */
5636 static void
5637 transmit_client_message (void *cls,
5638                          struct NeighbourList *n)
5639 {
5640   struct TransmitClientMessageContext *tcmc = cls;
5641   struct TransportClient *tc;
5642
5643   tc = clients;
5644   while ((tc != NULL) && (tc->client != tcmc->client))
5645     tc = tc->next;
5646
5647   if (n != NULL)
5648     {
5649       transmit_to_peer (tc, NULL, tcmc->priority,
5650                         GNUNET_TIME_absolute_get_remaining (tcmc->timeout),
5651                         (char *)&tcmc[1],
5652                         tcmc->msize, GNUNET_NO, n);
5653     }
5654   GNUNET_SERVER_receive_done (tcmc->client, GNUNET_OK);
5655   GNUNET_SERVER_client_drop (tcmc->client);
5656   GNUNET_free (tcmc);
5657 }
5658
5659
5660 /**
5661  * Handle SEND-message.
5662  *
5663  * @param cls closure (always NULL)
5664  * @param client identification of the client
5665  * @param message the actual message
5666  */
5667 static void
5668 handle_send (void *cls,
5669              struct GNUNET_SERVER_Client *client,
5670              const struct GNUNET_MessageHeader *message)
5671 {
5672   const struct OutboundMessage *obm;
5673   const struct GNUNET_MessageHeader *obmm;
5674   struct TransmitClientMessageContext *tcmc;
5675   uint16_t size;
5676   uint16_t msize;
5677
5678   size = ntohs (message->size);
5679   if (size <
5680       sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
5681     {
5682       GNUNET_break (0);
5683       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5684       return;
5685     }
5686   GNUNET_STATISTICS_update (stats,
5687                             gettext_noop ("# payload received for other peers"),
5688                             size,
5689                             GNUNET_NO);
5690   obm = (const struct OutboundMessage *) message;
5691   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
5692   msize = size - sizeof (struct OutboundMessage);
5693 #if DEBUG_TRANSPORT
5694   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5695               "Received `%s' request from client with target `%4s' and message of type %u and size %u\n",
5696               "SEND", GNUNET_i2s (&obm->peer),
5697               ntohs (obmm->type),
5698               msize);
5699 #endif
5700   tcmc = GNUNET_malloc (sizeof (struct TransmitClientMessageContext) + msize);
5701   tcmc->client = client;
5702   tcmc->priority = ntohl (obm->priority);
5703   tcmc->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_ntoh (obm->timeout));
5704   tcmc->msize = msize;
5705   /* FIXME: this memcpy can be up to 7% of our total runtime */
5706   memcpy (&tcmc[1], obmm, msize);
5707   GNUNET_SERVER_client_keep (client);
5708   setup_peer_check_blacklist (&obm->peer, GNUNET_YES,
5709                               &transmit_client_message,
5710                               tcmc);
5711 }
5712
5713
5714 /**
5715  * Handle request connect message
5716  *
5717  * @param cls closure (always NULL)
5718  * @param client identification of the client
5719  * @param message the actual message
5720  */
5721 static void
5722 handle_request_connect (void *cls,
5723                         struct GNUNET_SERVER_Client *client,
5724                         const struct GNUNET_MessageHeader *message)
5725 {
5726   const struct TransportRequestConnectMessage *trcm =
5727     (const struct TransportRequestConnectMessage *) message;
5728
5729   GNUNET_STATISTICS_update (stats,
5730                             gettext_noop ("# REQUEST CONNECT messages received"),
5731                             1,
5732                             GNUNET_NO);
5733 #if DEBUG_TRANSPORT
5734   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
5735              "Received a request connect message for peer `%s'\n",
5736              GNUNET_i2s(&trcm->peer));
5737 #endif
5738   setup_peer_check_blacklist (&trcm->peer, GNUNET_YES,
5739                               NULL, NULL);
5740   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5741 }
5742
5743
5744 /**
5745  * Handle SET_QUOTA-message.
5746  *
5747  * @param cls closure (always NULL)
5748  * @param client identification of the client
5749  * @param message the actual message
5750  */
5751 static void
5752 handle_set_quota (void *cls,
5753                   struct GNUNET_SERVER_Client *client,
5754                   const struct GNUNET_MessageHeader *message)
5755 {
5756   const struct QuotaSetMessage *qsm =
5757     (const struct QuotaSetMessage *) message;
5758   struct NeighbourList *n;
5759
5760   GNUNET_STATISTICS_update (stats,
5761                             gettext_noop ("# SET QUOTA messages received"),
5762                             1,
5763                             GNUNET_NO);
5764   n = find_neighbour (&qsm->peer);
5765   if (n == NULL)
5766     {
5767       GNUNET_SERVER_receive_done (client, GNUNET_OK);
5768       GNUNET_STATISTICS_update (stats,
5769                                 gettext_noop ("# SET QUOTA messages ignored (no such peer)"),
5770                                 1,
5771                                 GNUNET_NO);
5772       return;
5773     }
5774 #if DEBUG_TRANSPORT
5775   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5776               "Received `%s' request (new quota %u, old quota %u) from client for peer `%4s'\n",
5777               "SET_QUOTA",
5778               (unsigned int) ntohl (qsm->quota.value__),
5779               (unsigned int) n->in_tracker.available_bytes_per_s__,
5780               GNUNET_i2s (&qsm->peer));
5781 #endif
5782   GNUNET_BANDWIDTH_tracker_update_quota (&n->in_tracker,
5783                                          qsm->quota);
5784   if (0 == ntohl (qsm->quota.value__))
5785     {
5786 #if DEBUG_TRANSPORT
5787       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
5788                 "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&n->id),
5789                 "SET_QUOTA");
5790 #endif
5791       disconnect_neighbour (n, GNUNET_NO);
5792     }
5793   GNUNET_SERVER_receive_done (client, GNUNET_OK);
5794 }
5795
5796
5797 /**
5798  * Take the given address and append it to the set of results sent back to
5799  * the client.
5800  *
5801  * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
5802  * @param address the resolved name, NULL to indicate the last response
5803  */
5804 static void
5805 transmit_address_to_client (void *cls, const char *address)
5806 {
5807   struct GNUNET_SERVER_TransmitContext *tc = cls;
5808   size_t slen;
5809
5810   if (NULL == address)
5811     slen = 0;
5812   else
5813     slen = strlen (address) + 1;
5814
5815   GNUNET_SERVER_transmit_context_append_data (tc, address, slen,
5816                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
5817   if (NULL == address)
5818     GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
5819 }
5820
5821
5822 /**
5823  * Handle AddressLookup-message.
5824  *
5825  * @param cls closure (always NULL)
5826  * @param client identification of the client
5827  * @param message the actual message
5828  */
5829 static void
5830 handle_address_lookup (void *cls,
5831                        struct GNUNET_SERVER_Client *client,
5832                        const struct GNUNET_MessageHeader *message)
5833 {
5834   const struct AddressLookupMessage *alum;
5835   struct TransportPlugin *lsPlugin;
5836   const char *nameTransport;
5837   const char *address;
5838   uint16_t size;
5839   struct GNUNET_SERVER_TransmitContext *tc;
5840   struct GNUNET_TIME_Absolute timeout;
5841   struct GNUNET_TIME_Relative rtimeout;
5842   int32_t numeric;
5843
5844   size = ntohs (message->size);
5845   if (size < sizeof (struct AddressLookupMessage))
5846     {
5847       GNUNET_break_op (0);
5848       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5849       return;
5850     }
5851   alum = (const struct AddressLookupMessage *) message;
5852   uint32_t addressLen = ntohl (alum->addrlen);
5853   if (size <= sizeof (struct AddressLookupMessage) + addressLen)
5854     {
5855       GNUNET_break_op (0);
5856       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5857       return;
5858     }
5859   address = (const char *) &alum[1];
5860   nameTransport = (const char *) &address[addressLen];
5861   if (nameTransport
5862       [size - sizeof (struct AddressLookupMessage) - addressLen - 1] != '\0')
5863     {
5864       GNUNET_break_op (0);
5865       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
5866       return;
5867     }
5868   timeout = GNUNET_TIME_absolute_ntoh (alum->timeout);
5869   rtimeout = GNUNET_TIME_absolute_get_remaining (timeout);
5870   numeric = ntohl (alum->numeric_only);
5871   lsPlugin = find_transport (nameTransport);
5872   if (NULL == lsPlugin)
5873     {
5874       tc = GNUNET_SERVER_transmit_context_create (client);
5875       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
5876                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
5877       GNUNET_SERVER_transmit_context_run (tc, rtimeout);
5878       return;
5879     }
5880   tc = GNUNET_SERVER_transmit_context_create (client);
5881   lsPlugin->api->address_pretty_printer (lsPlugin->api->cls,
5882                                          nameTransport,
5883                                          address, addressLen,
5884                                          numeric,
5885                                          rtimeout,
5886                                          &transmit_address_to_client, tc);
5887 }
5888
5889
5890 /**
5891  * Setup the environment for this plugin.
5892  */
5893 static void
5894 create_environment (struct TransportPlugin *plug)
5895 {
5896   plug->env.cfg = cfg;
5897   plug->env.my_identity = &my_identity;
5898   plug->env.our_hello = &our_hello;
5899   plug->env.cls = plug;
5900   plug->env.receive = &plugin_env_receive;
5901   plug->env.notify_address = &plugin_env_notify_address;
5902   plug->env.session_end = &plugin_env_session_end;
5903   plug->env.max_connections = max_connect_per_transport;
5904   plug->env.stats = stats;
5905 }
5906
5907
5908 /**
5909  * Start the specified transport (load the plugin).
5910  */
5911 static void
5912 start_transport (struct GNUNET_SERVER_Handle *server,
5913                  const char *name)
5914 {
5915   struct TransportPlugin *plug;
5916   char *libname;
5917
5918   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
5919               _("Loading `%s' transport plugin\n"), name);
5920   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", name);
5921   plug = GNUNET_malloc (sizeof (struct TransportPlugin));
5922   create_environment (plug);
5923   plug->short_name = GNUNET_strdup (name);
5924   plug->lib_name = libname;
5925   plug->next = plugins;
5926   plugins = plug;
5927   plug->api = GNUNET_PLUGIN_load (libname, &plug->env);
5928   if (plug->api == NULL)
5929     {
5930       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
5931                   _("Failed to load transport plugin for `%s'\n"), name);
5932       GNUNET_free (plug->short_name);
5933       plugins = plug->next;
5934       GNUNET_free (libname);
5935       GNUNET_free (plug);
5936     }
5937 }
5938
5939
5940 /**
5941  * Called whenever a client is disconnected.  Frees our
5942  * resources associated with that client.
5943  *
5944  * @param cls closure
5945  * @param client identification of the client
5946  */
5947 static void
5948 client_disconnect_notification (void *cls,
5949                                 struct GNUNET_SERVER_Client *client)
5950 {
5951   struct TransportClient *pos;
5952   struct TransportClient *prev;
5953   struct ClientMessageQueueEntry *mqe;
5954   struct Blacklisters *bl;
5955   struct BlacklistCheck *bc;
5956
5957   if (client == NULL)
5958     return;
5959 #if DEBUG_TRANSPORT
5960   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
5961               "Client disconnected, cleaning up.\n");
5962 #endif
5963   /* clean up blacklister */
5964   bl = bl_head;
5965   while (bl != NULL)
5966     {
5967       if (bl->client == client)
5968         {
5969           bc = bc_head;
5970           while (bc != NULL)
5971             {
5972               if (bc->bl_pos == bl)
5973                 {
5974                   bc->bl_pos = bl->next;
5975                   if (bc->th != NULL)
5976                     {
5977                       GNUNET_CONNECTION_notify_transmit_ready_cancel (bc->th);
5978                       bc->th = NULL;
5979                     }
5980                   if (bc->task == GNUNET_SCHEDULER_NO_TASK)
5981                     bc->task = GNUNET_SCHEDULER_add_now (&do_blacklist_check,
5982                                                          bc);
5983                   break;
5984                 }
5985               bc = bc->next;
5986             }
5987           GNUNET_CONTAINER_DLL_remove (bl_head,
5988                                        bl_tail,
5989                                        bl);
5990           GNUNET_SERVER_client_drop (bl->client);
5991           GNUNET_free (bl);
5992           break;
5993         }
5994       bl = bl->next;
5995     }
5996   /* clean up 'normal' clients */
5997   prev = NULL;
5998   pos = clients;
5999   while ((pos != NULL) && (pos->client != client))
6000     {
6001       prev = pos;
6002       pos = pos->next;
6003     }
6004   if (pos == NULL)
6005     return;
6006   while (NULL != (mqe = pos->message_queue_head))
6007     {
6008       GNUNET_CONTAINER_DLL_remove (pos->message_queue_head,
6009                                    pos->message_queue_tail,
6010                                    mqe);
6011       pos->message_count--;
6012       GNUNET_free (mqe);
6013     }
6014   if (prev == NULL)
6015     clients = pos->next;
6016   else
6017     prev->next = pos->next;
6018   if (GNUNET_YES == pos->tcs_pending)
6019     {
6020       pos->client = NULL;
6021       return;
6022     }
6023   if (pos->th != NULL)
6024     {
6025       GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
6026       pos->th = NULL;
6027     }
6028   GNUNET_break (0 == pos->message_count);
6029   GNUNET_free (pos);
6030 }
6031
6032
6033 /**
6034  * Function called when the service shuts down.  Unloads our plugins
6035  * and cancels pending validations.
6036  *
6037  * @param cls closure, unused
6038  * @param tc task context (unused)
6039  */
6040 static void
6041 shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
6042 {
6043   struct TransportPlugin *plug;
6044   struct OwnAddressList *al;
6045   struct CheckHelloValidatedContext *chvc;
6046
6047   while (neighbours != NULL)
6048     {
6049 #if DEBUG_TRANSPORT
6050       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6051                   "Disconnecting peer `%4s', %s\n", GNUNET_i2s(&neighbours->id),
6052                   "SHUTDOWN_TASK");
6053 #endif
6054       disconnect_neighbour (neighbours, GNUNET_NO);
6055     }
6056 #if DEBUG_TRANSPORT
6057   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6058               "Transport service is unloading plugins...\n");
6059 #endif
6060   while (NULL != (plug = plugins))
6061     {
6062       plugins = plug->next;
6063       if (plug->address_update_task != GNUNET_SCHEDULER_NO_TASK)
6064         {
6065           GNUNET_SCHEDULER_cancel (plug->address_update_task);
6066           plug->address_update_task = GNUNET_SCHEDULER_NO_TASK;
6067         }
6068       GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
6069       GNUNET_free (plug->lib_name);
6070       GNUNET_free (plug->short_name);
6071       while (NULL != (al = plug->addresses))
6072         {
6073           plug->addresses = al->next;
6074           GNUNET_free (al);
6075         }
6076       GNUNET_free (plug);
6077     }
6078   if (my_private_key != NULL)
6079     GNUNET_CRYPTO_rsa_key_free (my_private_key);
6080   GNUNET_free_non_null (our_hello);
6081
6082   GNUNET_CONTAINER_multihashmap_iterate (validation_map,
6083                                          &abort_validation,
6084                                          NULL);
6085   GNUNET_CONTAINER_multihashmap_destroy (validation_map);
6086   validation_map = NULL;
6087
6088   ats_shutdown(ats);
6089
6090   /* free 'chvc' data structure */
6091   while (NULL != (chvc = chvc_head))
6092     {
6093       chvc_head = chvc->next;
6094       if (chvc->piter != NULL)
6095         {
6096           GNUNET_PEERINFO_iterate_cancel (chvc->piter);
6097           GNUNET_STATISTICS_update (stats,
6098                                     gettext_noop ("# outstanding peerinfo iterate requests"),
6099                                     -1,
6100                                     GNUNET_NO);
6101           chvc->ve_count --;
6102         }
6103       else
6104           GNUNET_break (0);
6105       GNUNET_assert (chvc->ve_count == 0);
6106       GNUNET_free (chvc);
6107     }
6108   chvc_tail = NULL;
6109
6110   if (stats != NULL)
6111     {
6112       GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
6113       stats = NULL;
6114     }
6115   if (peerinfo != NULL)
6116     {
6117       GNUNET_PEERINFO_disconnect (peerinfo);
6118       peerinfo = NULL;
6119     }
6120   /* Can we assume those are gone by now, or do we need to clean up
6121      explicitly!? */
6122   GNUNET_break (bl_head == NULL);
6123   GNUNET_break (bc_head == NULL);
6124 }
6125
6126 #if HAVE_LIBGLPK
6127 static int ats_evaluate_results (int result, int solution, char * problem)
6128 {
6129         int cont = GNUNET_NO;
6130         int error_kind = GNUNET_ERROR_TYPE_DEBUG;
6131 #if DEBUG_ATS
6132         error_kind = GNUNET_ERROR_TYPE_ERROR;
6133 #endif
6134
6135         switch (result) {
6136         case GLP_ESTOP  :    /* search terminated by application */
6137                 GNUNET_log (error_kind, "%s , Search terminated by application\n", problem);
6138                 break;
6139         case GLP_EITLIM :    /* iteration limit exceeded */
6140                 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s Iteration limit exceeded\n", problem);
6141                 break;
6142         break;
6143         case GLP_ETMLIM :    /* time limit exceeded */
6144                 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s Time limit exceeded\n", problem);
6145         break;
6146         case GLP_ENOPFS :    /* no primal feasible solution */
6147         case GLP_ENODFS :    /* no dual feasible solution */
6148                 GNUNET_log (error_kind, "%s No feasible solution\n", problem);
6149         break;
6150
6151         case GLP_EBADB  :    /* invalid basis */
6152         case GLP_ESING  :    /* singular matrix */
6153         case GLP_ECOND  :    /* ill-conditioned matrix */
6154         case GLP_EBOUND :    /* invalid bounds */
6155         case GLP_EFAIL  :    /* solver failed */
6156         case GLP_EOBJLL :    /* objective lower limit reached */
6157         case GLP_EOBJUL :    /* objective upper limit reached */
6158         case GLP_EROOT  :    /* root LP optimum not provided */
6159                 GNUNET_log (error_kind, "%s Invalid Input data: %i\n", problem, result);
6160         break;
6161
6162         case 0:
6163                         GNUNET_log (error_kind, "%s Problem has been solved\n", problem);
6164         break;
6165         }
6166
6167         switch (solution) {
6168                 case GLP_UNDEF:
6169                         GNUNET_log (error_kind, "%s solution is undeﬁned\n", problem);
6170                         break;
6171                 case GLP_OPT:
6172                         GNUNET_log (error_kind, "%s solution is optimal\n", problem);
6173                         cont=GNUNET_YES;
6174                         break;
6175                 case GLP_FEAS:
6176                         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"));
6177                         cont=GNUNET_YES;
6178                         break;
6179                 case GLP_NOFEAS:
6180                         GNUNET_log (error_kind, "%s problem has no %sfeasible solution\n", problem,  (0==strcmp(problem,"LP")?"":"integer "));
6181                         break;
6182                 case GLP_INFEAS:
6183                         GNUNET_log (error_kind, "%s problem is infeasible \n", problem);
6184                         break;
6185                 case GLP_UNBND:
6186                         GNUNET_log (error_kind, "%s problem is unbounded \n", problem);
6187                 default:
6188                         break;
6189         }
6190 return cont;
6191 }
6192
6193 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)
6194 {
6195         int result;
6196         int lp_solution;
6197         int mlp_solution;
6198
6199         // Solving simplex
6200
6201         glp_smcp opt_lp;
6202         glp_init_smcp(&opt_lp);
6203 #if VERBOSE_ATS
6204         opt_lp.msg_lev = GLP_MSG_ALL;
6205 #else
6206         opt_lp.msg_lev = GLP_MSG_OFF;
6207 #endif
6208
6209         // setting iteration limit
6210         opt_lp.it_lim = max_it;
6211         // maximum duration
6212         opt_lp.tm_lim = max_dur;
6213
6214         if (ats->stat.recreate_problem == GNUNET_YES)
6215                 opt_lp.presolve = GLP_ON;
6216         result = glp_simplex(ats->prob, &opt_lp);
6217         lp_solution =  glp_get_status (ats->prob);
6218
6219         if ((result == GLP_ETMLIM) || (result == GLP_ETMLIM))
6220         {
6221                 ats->stat.valid = GNUNET_NO;
6222                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ATS exceeded time or iteration limit!\n");
6223                 return;
6224         }
6225
6226         if (ats_evaluate_results(result, lp_solution, "LP") == GNUNET_YES)
6227         {
6228                         stat->valid = GNUNET_YES;
6229         }
6230         else
6231         {
6232                 ats->stat.simplex_rerun_required = GNUNET_YES;
6233                 opt_lp.presolve = GLP_ON;
6234                 result = glp_simplex(ats->prob, &opt_lp);
6235                 lp_solution =  glp_get_status (ats->prob);
6236
6237                 // TODO: Remove if this does not appear until release
6238                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "EXECUTED SIMPLEX WITH PRESOLVER! %i \n", lp_solution);
6239
6240                 if (ats_evaluate_results(result, lp_solution, "LP") != GNUNET_YES)
6241                 {
6242                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "After execution simplex with presolver: STILL INVALID!\n");
6243                         char * filename;
6244                         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);
6245                         glp_write_lp (ats->prob, NULL, filename);
6246                         GNUNET_free (filename);
6247                         stat->valid = GNUNET_NO;
6248                         ats->stat.recreate_problem = GNUNET_YES;
6249                         return;
6250                 }
6251                 stat->valid = GNUNET_YES;
6252         }
6253
6254         // Solving mlp
6255         glp_iocp opt_mlp;
6256         glp_init_iocp(&opt_mlp);
6257         // maximum duration
6258         opt_mlp.tm_lim = max_dur;
6259         // output level
6260 #if VERBOSE_ATS
6261         opt_mlp.msg_lev = GLP_MSG_ALL;
6262 #else
6263         opt_mlp.msg_lev = GLP_MSG_OFF;
6264 #endif
6265
6266         result = glp_intopt (ats->prob, &opt_mlp);
6267         mlp_solution =  glp_mip_status (ats->prob);
6268         stat->solution = mlp_solution;
6269
6270         if (ats_evaluate_results(result, mlp_solution, "MLP") == GNUNET_YES)
6271         {
6272                 stat->valid = GNUNET_YES;
6273         }
6274         else
6275         {
6276                 // TODO: Remove if this does not appear until release
6277                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,  "MLP SOLUTION INVALID: %i\n", lp_solution);
6278                 stat->valid = GNUNET_NO;
6279         }
6280
6281 /*
6282         int check;
6283         int error = GNUNET_NO;
6284         double bw;
6285         struct ATS_mechanism *t = NULL;
6286         for (c=1; c<= (c_peers); c++ )
6287         {
6288                 check = GNUNET_NO;
6289                 t = peers[c].m_head;
6290                 while (t!=NULL)
6291                 {
6292                         bw = glp_get_col_prim(prob, t->col_index);
6293                         if (bw > 1.0)
6294                         {
6295 #if VERBOSE_ATS
6296                                 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);
6297 #endif
6298                                 if (check ==GNUNET_YES)
6299                                 {
6300                                         glp_write_sol(prob, "invalid_solution.mlp");
6301                                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid solution, check invalid_solution.mlp");
6302                                         GNUNET_STATISTICS_update (stats, "ATS invalid solutions", 1, GNUNET_NO);
6303                                         error = GNUNET_YES;
6304                                 }
6305                                 if (check ==GNUNET_NO)
6306                                         check = GNUNET_YES;
6307                         }
6308                         t = t->next;
6309                 }
6310         }*/
6311
6312 #if VERBOSE_ATS
6313         if (glp_get_col_prim(ats->prob,2*c_mechs+1) != 1)
6314         {
6315         int c;
6316         for (c=1; c<= available_quality_metrics; c++ )
6317         {
6318                 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));
6319         }
6320         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));
6321         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));
6322         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));
6323         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "objective value:  %f\n", glp_mip_obj_val(ats->prob));
6324         }
6325 #endif
6326 }
6327
6328 static void ats_delete_problem ()
6329 {
6330 #if DEBUG_ATS
6331         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Deleting problem\n");
6332 #endif
6333         int c;
6334
6335         for (c=0; c< (ats->stat).c_mechs; c++)
6336                 GNUNET_free_non_null (ats->mechanisms[c].rc);
6337
6338
6339         if (ats->mechanisms!=NULL)
6340         {
6341                 GNUNET_free(ats->mechanisms);
6342                 ats->mechanisms = NULL;
6343         }
6344
6345         if (ats->peers!=NULL)
6346         {
6347                 GNUNET_free(ats->peers);
6348                 ats->peers = NULL;
6349         }
6350
6351         if (ats->prob != NULL)
6352         {
6353                 glp_delete_prob(ats->prob);
6354                 ats->prob = NULL;
6355         }
6356
6357         ats->stat.begin_cr = GNUNET_SYSERR;
6358         ats->stat.begin_qm = GNUNET_SYSERR;
6359         ats->stat.c_mechs = 0;
6360         ats->stat.c_peers = 0;
6361         ats->stat.end_cr = GNUNET_SYSERR;
6362         ats->stat.end_qm = GNUNET_SYSERR;
6363         ats->stat.solution = GNUNET_SYSERR;
6364         ats->stat.valid = GNUNET_SYSERR;
6365 }
6366
6367
6368 static void ats_update_problem_qm ()
6369 {
6370         int array_index;
6371         int row_index;
6372         int c, c2;
6373         int c_q_metrics = available_quality_metrics;
6374
6375         int *ja    = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (int));
6376         double *ar = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (double));
6377 #if DEBUG_ATS
6378                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
6379 #endif
6380         row_index = ats->stat.begin_qm;
6381
6382         for (c=1; c <= c_q_metrics; c++)
6383         {
6384                 array_index = 1;
6385                 double value = 1;
6386 #if VERBOSE_ATS
6387                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6388 #endif
6389
6390                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6391                 for (c2=1; c2<=ats->stat.c_mechs; c2++)
6392                 {
6393                         ja[array_index] = c2;
6394
6395                         GNUNET_assert (ats->mechanisms[c2].addr != NULL);
6396                         GNUNET_assert (ats->mechanisms[c2].peer != NULL);
6397
6398                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
6399                         {
6400                                 double v0 = 0, v1 = 0, v2 = 0;
6401
6402                                 v0 = ats->mechanisms[c2].addr->quality[c-1].values[0];
6403                                 if (v1 < 1) v0 = 0.1;
6404                                 v1 = ats->mechanisms[c2].addr->quality[c-1].values[1];
6405                                 if (v1 < 1) v0 = 0.1;
6406                                 v2 = ats->mechanisms[c2].addr->quality[c-1].values[2];
6407                                 if (v1 < 1) v0 = 0.1;
6408                                 value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
6409                                 //value = 1;
6410                         }
6411                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
6412                         {
6413                                 double v0 = 0, v1 = 0, v2 = 0;
6414                                 v0 = ats->mechanisms[c2].addr->quality[c-1].values[0];
6415                                 if (v0 < 1) v0 = 1;
6416                                 v1 = ats->mechanisms[c2].addr->quality[c-1].values[1];
6417                                 if (v1 < 1) v1 = 1;
6418                                 v2 = ats->mechanisms[c2].addr->quality[c-1].values[2];
6419                                 if (v2 < 1) v2 = 1;
6420                                 value =  (v0 + 2 * v1 + 3 * v2) / 6.0;
6421                                 if (value >= 1)
6422                                         value =  (double) 10 / value;
6423                                 else
6424                                         value = 10;
6425                         }
6426                         ar[array_index] = (ats->mechanisms[c2].peer->f) * value;
6427 #if VERBOSE_ATS
6428                         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]);
6429 #endif
6430                         array_index++;
6431                 }
6432                 ja[array_index] = ats->stat.col_qm + c - 1;
6433                 ar[array_index] = -1;
6434
6435 #if VERBOSE_ATS
6436                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, row_index, ja[array_index], ar[array_index]);
6437 #endif
6438                 glp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
6439
6440                 array_index = 1;
6441                 row_index++;
6442         }
6443
6444         GNUNET_free_non_null (ja);
6445         GNUNET_free_non_null (ar);
6446 }
6447
6448
6449 static void ats_update_problem_cr ()
6450 {
6451
6452         int array_index;
6453         int row_index;
6454         int c, c2;
6455         double ct_max, ct_min;
6456
6457         int *ja    = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (int));
6458         double *ar = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (double));
6459
6460         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics\n");
6461         row_index = ats->stat.begin_cr;
6462         array_index = 1;
6463
6464         for (c=0; c<available_ressources; c++)
6465         {
6466                 ct_max = ressources[c].c_max;
6467                 ct_min = ressources[c].c_min;
6468 #if VERBOSE_ATS
6469                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",row_index, ct_min, ct_max);
6470 #endif
6471                 glp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
6472
6473                 for (c2=1; c2<=ats->stat.c_mechs; c2++)
6474                 {
6475                         double value = 0;
6476
6477                         GNUNET_assert (ats->mechanisms[c2].addr != NULL);
6478                         GNUNET_assert (ats->mechanisms[c2].peer != NULL);
6479
6480                         ja[array_index] = c2;
6481                         value = ats->mechanisms[c2].addr->ressources[c].c;
6482                         ar[array_index] = value;
6483 #if VERBOSE_ATS
6484                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, row_index, ja[array_index], ar[array_index]);
6485 #endif
6486                         array_index++;
6487                 }
6488                 glp_set_mat_row (ats->prob, row_index, array_index, ja, ar);
6489
6490                 row_index ++;
6491         }
6492
6493
6494         GNUNET_free_non_null (ja);
6495         GNUNET_free_non_null (ar);
6496 }
6497
6498
6499 #if 0
6500 static void ats_update_problem_qm_TEST ()
6501 {
6502         int row_index;
6503         int c, c2;
6504
6505         int old_ja[ats->stat.c_mechs + 2];
6506         double old_ar[ats->stat.c_mechs + 2];
6507         int c_old;
6508         int changed = 0;
6509
6510         int *ja    = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (int));
6511         double *ar = GNUNET_malloc ((1 + ats->stat.c_mechs*2 + 3 + available_quality_metrics) * sizeof (double));
6512 #if DEBUG_ATS
6513         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Updating problem quality metrics TEST\n");
6514 #endif
6515         if (ats->stat.begin_qm >0)
6516                 row_index = ats->stat.begin_qm;
6517         else
6518                 return;
6519
6520
6521         for (c=0; c<available_quality_metrics; c++)
6522         {
6523
6524                 c_old = glp_get_mat_row (ats->prob, row_index, old_ja, old_ar);
6525
6526                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6527
6528                 for (c2=1; c2<=c_old; c2++)
6529                 {
6530                         ja[c2] = old_ja[c2];
6531                         if ((changed < 3) && (c2>2) && (old_ar[c2] != -1))
6532                         {
6533                                 ar[c2] = old_ar[c2] + 5 - changed;
6534                                 changed ++;
6535                         }
6536                         else
6537                                 ar[c2] = old_ar[c2];
6538 #if VERBOSE_ATS
6539                         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]);
6540 #endif
6541                 }
6542                 glp_set_mat_row (ats->prob, row_index, c_old, ja, ar);
6543
6544                 row_index ++;
6545         }
6546
6547         GNUNET_free_non_null (ja);
6548         GNUNET_free_non_null (ar);
6549 }
6550 #endif //END: HAVE_LIBGLPK
6551
6552 /** solve the bandwidth distribution problem
6553  * @param max_it maximum iterations
6554  * @param max_dur maximum duration in ms
6555  * @param D     weight for diversity
6556  * @param U weight for utility
6557  * @param R weight for relativity
6558  * @param v_b_min minimal bandwidth per peer
6559  * @param v_n_min minimum number of connections
6560  * @param stat result struct
6561  * @return GNUNET_SYSERR if glpk is not available, number of mechanisms used
6562  */
6563 static int ats_create_problem (double D, double U, double R, int v_b_min, int v_n_min, struct ATS_stat *stat)
6564 {
6565         ats->prob = glp_create_prob();
6566
6567         int c;
6568         int c_peers = 0;
6569         int c_mechs = 0;
6570
6571         int c_c_ressources = available_ressources;
6572         int c_q_metrics = available_quality_metrics;
6573
6574         double M = VERY_BIG_DOUBLE_VALUE;
6575         double Q[c_q_metrics+1];
6576         for (c=1; c<=c_q_metrics; c++)
6577         {
6578                 Q[c] = 1;
6579         }
6580
6581         struct NeighbourList *next = neighbours;
6582         while (next!=NULL)
6583         {
6584                 int found_addresses = GNUNET_NO;
6585                 struct ReadyList *r_next = next->plugins;
6586                 while (r_next != NULL)
6587                 {
6588                         struct ForeignAddressList * a_next = r_next->addresses;
6589                         while (a_next != NULL)
6590                         {
6591                                 c_mechs++;
6592                                 found_addresses = GNUNET_YES;
6593                                 a_next = a_next->next;
6594                         }
6595                         r_next = r_next->next;
6596                 }
6597                 if (found_addresses) c_peers++;
6598                 next = next->next;
6599         }
6600
6601         if (c_mechs==0)
6602         {
6603 #if DEBUG_ATS
6604                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No addresses for bw distribution available\n", c_peers);
6605 #endif
6606                 stat->valid = GNUNET_NO;
6607                 stat->c_peers = 0;
6608                 stat->c_mechs = 0;
6609                 return GNUNET_SYSERR;
6610         }
6611
6612         ats->mechanisms = GNUNET_malloc((1+c_mechs) * sizeof (struct ATS_mechanism));
6613         ats->peers =  GNUNET_malloc((1+c_peers) * sizeof (struct ATS_peer));
6614
6615         struct ATS_mechanism * mechanisms = ats->mechanisms;
6616         struct ATS_peer * peers = ats->peers;
6617
6618         c_mechs = 1;
6619         c_peers = 1;
6620
6621         next = neighbours;
6622         while (next!=NULL)
6623         {
6624                 int found_addresses = GNUNET_NO;
6625                 struct ReadyList *r_next = next->plugins;
6626                 while (r_next != NULL)
6627                 {
6628                         struct ForeignAddressList * a_next = r_next->addresses;
6629                         while (a_next != NULL)
6630                         {
6631                                 if (found_addresses == GNUNET_NO)
6632                                 {
6633                                         peers[c_peers].peer = next->id;
6634                                         peers[c_peers].m_head = NULL;
6635                                         peers[c_peers].m_tail = NULL;
6636                                         peers[c_peers].f = 1.0 / c_mechs;
6637                                 }
6638
6639                                 mechanisms[c_mechs].addr = a_next;
6640                                 mechanisms[c_mechs].col_index = c_mechs;
6641                                 mechanisms[c_mechs].peer = &peers[c_peers];
6642                                 mechanisms[c_mechs].next = NULL;
6643                                 mechanisms[c_mechs].plugin = r_next->plugin;
6644
6645                                 GNUNET_CONTAINER_DLL_insert_tail(peers[c_peers].m_head, peers[c_peers].m_tail, &mechanisms[c_mechs]);
6646                                 found_addresses = GNUNET_YES;
6647                                 c_mechs++;
6648
6649                                 a_next = a_next->next;
6650                         }
6651                         r_next = r_next->next;
6652                 }
6653                 if (found_addresses == GNUNET_YES)
6654                         c_peers++;
6655                 next = next->next;
6656         }
6657         c_mechs--;
6658         c_peers--;
6659
6660         if (v_n_min > c_peers)
6661                 v_n_min = c_peers;
6662
6663 #if VERBOSE_ATS
6664         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);
6665 #endif
6666
6667         int size =  1 + 3 + 10 *c_mechs + c_peers + (c_q_metrics*c_mechs)+ c_q_metrics + c_c_ressources * c_mechs ;
6668         int row_index;
6669         int array_index=1;
6670         int * ia = GNUNET_malloc (size * sizeof (int));
6671         int * ja = GNUNET_malloc (size * sizeof (int));
6672         double * ar = GNUNET_malloc(size* sizeof (double));
6673
6674         glp_set_prob_name(ats->prob, "gnunet ats bandwidth distribution");
6675         glp_set_obj_dir(ats->prob, GLP_MAX);
6676
6677         /* adding columns */
6678         char * name;
6679         glp_add_cols(ats->prob, 2 * c_mechs);
6680         /* adding b_t cols */
6681         for (c=1; c <= c_mechs; c++)
6682         {
6683
6684                 GNUNET_asprintf(&name, "p_%s_b%i",GNUNET_i2s(&(mechanisms[c].peer->peer)), c);
6685                 glp_set_col_name(ats->prob, c, name);
6686                 GNUNET_free (name);
6687                 glp_set_col_bnds(ats->prob, c, GLP_LO, 0.0, 0.0);
6688                 glp_set_obj_coef(ats->prob, c, 0);
6689
6690         }
6691         /* adding n_t cols */
6692         for (c=c_mechs+1; c <= 2*c_mechs; c++)
6693         {
6694                 GNUNET_asprintf(&name, "p_%s_n%i",GNUNET_i2s(&(mechanisms[c-c_mechs].peer->peer)),(c-c_mechs));
6695                 glp_set_col_name(ats->prob, c, name);
6696                 GNUNET_free (name);
6697                 glp_set_col_bnds(ats->prob, c, GLP_DB, 0.0, 1.0);
6698                 glp_set_col_kind(ats->prob, c, GLP_IV);
6699                 glp_set_obj_coef(ats->prob, c, 0);
6700         }
6701
6702         /* feasibility constraints */
6703         /* Constraint 1: one address per peer*/
6704         row_index = 1;
6705         glp_add_rows(ats->prob, c_peers);
6706         for (c=1; c<=c_peers; c++)
6707         {
6708 #if VERBOSE_ATS
6709                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6710 #endif
6711                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 1.0, 1.0);
6712
6713                 struct ATS_mechanism *m = peers[c].m_head;
6714                 while (m!=NULL)
6715                 {
6716                         ia[array_index] = row_index;
6717                         ja[array_index] = (c_mechs + m->col_index);
6718                         ar[array_index] = 1;
6719 #if VERBOSE_ATS
6720                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6721 #endif
6722                         array_index++;
6723                         m = m->next;
6724                 }
6725                 row_index++;
6726         }
6727
6728         /* Constraint 2: only active mechanism gets bandwidth assigned */
6729         glp_add_rows(ats->prob, c_mechs);
6730         for (c=1; c<=c_mechs; c++)
6731         {
6732                 /* b_t - n_t * M <= 0 */
6733 #if VERBOSE_ATS
6734                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6735 #endif
6736                 glp_set_row_bnds(ats->prob, row_index, GLP_UP, 0.0, 0.0);
6737
6738                 ia[array_index] = row_index;
6739                 ja[array_index] = mechanisms[c].col_index;
6740                 ar[array_index] = 1;
6741 #if VERBOSE_ATS
6742                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6743 #endif
6744                 array_index++;
6745                 ia[array_index] = row_index;
6746                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6747                 ar[array_index] = -M;
6748 #if VERBOSE_ATS
6749                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6750 #endif
6751                 array_index++;
6752                 row_index ++;
6753         }
6754
6755         /* Constraint 3: minimum bandwidth*/
6756         glp_add_rows(ats->prob, c_mechs);
6757         for (c=1; c<=c_mechs; c++)
6758         {
6759                 /* b_t - n_t * b_min <= 0 */
6760 #if VERBOSE_ATS
6761                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6762 #endif
6763                 glp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
6764
6765                 ia[array_index] = row_index;
6766                 ja[array_index] = mechanisms[c].col_index;
6767                 ar[array_index] = 1;
6768 #if VERBOSE_ATS
6769                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6770 #endif
6771                 array_index++;
6772                 ia[array_index] = row_index;
6773                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6774                 ar[array_index] = -v_b_min;
6775 #if VERBOSE_ATS
6776                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6777 #endif
6778                 array_index++;
6779                 row_index ++;
6780         }
6781         int c2;
6782         /* Constraint 4: max ressource capacity */
6783         /* V cr: bt * ct_r <= cr_max
6784          * */
6785         glp_add_rows(ats->prob, available_ressources);
6786         double ct_max = VERY_BIG_DOUBLE_VALUE;
6787         double ct_min = 0.0;
6788
6789         stat->begin_cr = array_index;
6790
6791         for (c=0; c<available_ressources; c++)
6792         {
6793                 ct_max = ressources[c].c_max;
6794                 ct_min = ressources[c].c_min;
6795 #if VERBOSE_ATS
6796                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] %f..%f\n",row_index, ct_min, ct_max);
6797 #endif
6798                 glp_set_row_bnds(ats->prob, row_index, GLP_DB, ct_min, ct_max);
6799
6800                 for (c2=1; c2<=c_mechs; c2++)
6801                 {
6802                         double value = 0;
6803                         ia[array_index] = row_index;
6804                         ja[array_index] = c2;
6805                         value = mechanisms[c2].addr->ressources[c].c;
6806                         ar[array_index] = value;
6807 #if VERBOSE_ATS
6808                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6809 #endif
6810                         array_index++;
6811                 }
6812                 row_index ++;
6813         }
6814         stat->end_cr = array_index--;
6815
6816         /* Constraint 5: min number of connections*/
6817         glp_add_rows(ats->prob, 1);
6818         for (c=1; c<=c_mechs; c++)
6819         {
6820                 // b_t - n_t * b_min >= 0
6821 #if VERBOSE_ATS
6822                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6823 #endif
6824                 glp_set_row_bnds(ats->prob, row_index, GLP_LO, v_n_min, 0.0);
6825
6826                 ia[array_index] = row_index;
6827                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6828                 ar[array_index] = 1;
6829 #if VERBOSE_ATS
6830                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6831 #endif
6832                 array_index++;
6833         }
6834         row_index ++;
6835
6836         // optimisation constraints
6837
6838         // adding columns
6839
6840         // Constraint 6: optimize for diversity
6841         int col_d;
6842         col_d = glp_add_cols(ats->prob, 1);
6843         stat->col_d = col_d;
6844         //GNUNET_assert (col_d == (2*c_mechs) + 1);
6845         glp_set_col_name(ats->prob, col_d, "d");
6846         glp_set_obj_coef(ats->prob, col_d, D);
6847         glp_set_col_bnds(ats->prob, col_d, GLP_LO, 0.0, 0.0);
6848         glp_add_rows(ats->prob, 1);
6849 #if VERBOSE_ATS
6850         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6851 #endif
6852         glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6853         for (c=1; c<=c_mechs; c++)
6854         {
6855                 // b_t - n_t * b_min >= 0
6856                 ia[array_index] = row_index;
6857                 ja[array_index] = c_mechs + mechanisms[c].col_index;
6858                 ar[array_index] = 1;
6859 #if VERBOSE_ATS
6860                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6861 #endif
6862                 array_index++;
6863         }
6864         ia[array_index] = row_index;
6865         ja[array_index] = col_d;
6866         ar[array_index] = -1;
6867 #if VERBOSE_ATS
6868         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6869 #endif
6870         array_index++;
6871         row_index ++;
6872
6873
6874         // Constraint 7: optimize for quality
6875         int col_qm;
6876         col_qm = glp_add_cols(ats->prob, c_q_metrics);
6877         stat->col_qm = col_qm;
6878         //GNUNET_assert (col_qm == (2*c_mechs) + 3 + 1);
6879         for (c=0; c< c_q_metrics; c++)
6880         {
6881                 GNUNET_asprintf(&name, "Q_%s",qm[c].name);
6882                 glp_set_col_name(ats->prob, col_qm + c, name);
6883                 glp_set_col_bnds(ats->prob, col_qm + c, GLP_LO, 0.0, 0.0);
6884                 GNUNET_free (name);
6885                 glp_set_obj_coef(ats->prob, col_qm + c, Q[c]);
6886         }
6887     glp_add_rows(ats->prob, available_quality_metrics);
6888         stat->begin_qm = row_index;
6889         for (c=1; c <= c_q_metrics; c++)
6890         {
6891 #if VERBOSE_ATS
6892                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6893 #endif
6894                 double value = 1;
6895                 glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6896                 for (c2=1; c2<=c_mechs; c2++)
6897                 {
6898
6899                         ia[array_index] = row_index;
6900                         ja[array_index] = c2;
6901                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY)
6902                         {
6903                                 double v0 = 0, v1 = 0, v2 = 0;
6904                                 v0 = mechanisms[c2].addr->quality[c-1].values[0];
6905                                 if (v1 < 1) v0 = 0.1;
6906                                 v1 = mechanisms[c2].addr->quality[c-1].values[1];
6907                                 if (v1 < 1) v0 = 0.1;
6908                                 v2 = mechanisms[c2].addr->quality[c-1].values[2];
6909                                 if (v1 < 1) v0 = 0.1;
6910                                 value = 100.0 / ((v0 + 2 * v1 + 3 * v2) / 6.0);
6911                                 value = 1;
6912                         }
6913                         if (qm[c-1].atis_index  == GNUNET_TRANSPORT_ATS_QUALITY_NET_DISTANCE)
6914                         {
6915                                 double v0 = 0, v1 = 0, v2 = 0;
6916                                 v0 = mechanisms[c2].addr->quality[c-1].values[0];
6917                                 if (v0 < 1) v0 = 1;
6918                                 v1 = mechanisms[c2].addr->quality[c-1].values[1];
6919                                 if (v1 < 1) v1 = 1;
6920                                 v2 = mechanisms[c2].addr->quality[c-1].values[2];
6921                                 if (v2 < 1) v2 = 1;
6922                                 value =  (v0 + 2 * v1 + 3 * v2) / 6.0;
6923                                 if (value >= 1)
6924                                         value =  (double) 10 / value;
6925                                 else
6926                                         value = 10;
6927                         }
6928                         ar[array_index] = (mechanisms[c2].peer->f) * value ;
6929 #if VERBOSE_ATS
6930                         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]);
6931 #endif
6932                         array_index++;
6933                 }
6934
6935                 ia[array_index] = row_index;
6936                 ja[array_index] = col_qm + c - 1;
6937                 ar[array_index] = -1;
6938 #if VERBOSE_ATS
6939                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6940 #endif
6941                 array_index++;
6942                 row_index++;
6943         }
6944         stat->end_qm = row_index-1;
6945
6946         // Constraint 8: optimize bandwidth utility
6947         int col_u;
6948         col_u = glp_add_cols(ats->prob, 1);
6949         stat->col_u = col_u;
6950         //GNUNET_assert (col_u == (2*c_mechs) + 2);
6951         glp_set_col_name(ats->prob, col_u, "u");
6952         glp_set_obj_coef(ats->prob, col_u, U);
6953         glp_set_col_bnds(ats->prob, col_u, GLP_LO, 0.0, 0.0);
6954         glp_add_rows(ats->prob, 1);
6955 #if VERBOSE_ATS
6956         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "bounds [row]=[%i] \n",row_index);
6957 #endif
6958         glp_set_row_bnds(ats->prob, row_index, GLP_FX, 0.0, 0.0);
6959         for (c=1; c<=c_mechs; c++)
6960         {
6961                 ia[array_index] = row_index;
6962                 ja[array_index] = c;
6963                 ar[array_index] = mechanisms[c].peer->f;
6964 #if VERBOSE_ATS
6965                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6966 #endif
6967                 array_index++;
6968         }
6969         ia[array_index] = row_index;
6970         ja[array_index] = col_u;
6971         ar[array_index] = -1;
6972 #if VERBOSE_ATS
6973         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
6974 #endif
6975
6976         array_index++;
6977         row_index ++;
6978
6979         // Constraint 9: optimize relativity
6980         int col_r;
6981         col_r = glp_add_cols(ats->prob, 1);
6982         stat->col_r = col_r;
6983         //GNUNET_assert (col_r == (2*c_mechs) + 3);
6984         glp_set_col_name(ats->prob, col_r, "r");
6985         glp_set_obj_coef(ats->prob, col_r, R);
6986         glp_set_col_bnds(ats->prob, col_r, GLP_LO, 0.0, 0.0);
6987         glp_add_rows(ats->prob, c_peers);
6988         for (c=1; c<=c_peers; c++)
6989         {
6990                 glp_set_row_bnds(ats->prob, row_index, GLP_LO, 0.0, 0.0);
6991
6992                 struct ATS_mechanism *m = peers[c].m_head;
6993                 while (m!=NULL)
6994                 {
6995                         ia[array_index] = row_index;
6996                         ja[array_index] = m->col_index;
6997                         ar[array_index] = 1 / mechanisms[c].peer->f;
6998 #if VERBOSE_ATS
6999                         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
7000 #endif
7001                         array_index++;
7002                         m = m->next;
7003                 }
7004                 ia[array_index] = row_index;
7005                 ja[array_index] = col_r;
7006                 ar[array_index] = -1;
7007 #if VERBOSE_ATS
7008                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "[index]=[%i]: [%i,%i]=%f \n",array_index, ia[array_index], ja[array_index], ar[array_index]);
7009 #endif
7010                 array_index++;
7011
7012                 row_index++;
7013         }
7014
7015         /* Loading the matrix */
7016         glp_load_matrix(ats->prob, array_index-1, ia, ja, ar);
7017
7018         stat->c_mechs = c_mechs;
7019         stat->c_peers = c_peers;
7020         stat->solution = 0;
7021         stat->valid = GNUNET_YES;
7022
7023         /* clean up */
7024
7025         GNUNET_free (ja);
7026         GNUNET_free (ia);
7027         GNUNET_free (ar);
7028
7029         return GNUNET_OK;
7030
7031 }
7032
7033 void ats_notify_ats_data (
7034                 const struct GNUNET_PeerIdentity *peer,
7035                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data)
7036 {
7037 #if DEBUG_ATS
7038         GNUNET_log (GNUNET_ERROR_TYPE_BULK, "ATS_notify_ats_data: %s\n",GNUNET_i2s(peer));
7039 #endif
7040         ats_calculate_bandwidth_distribution();
7041 }
7042 #endif //END: HAVE_LIBGLPK
7043
7044 static void
7045 ats_calculate_bandwidth_distribution ()
7046 {
7047 #if HAVE_LIBGLPK
7048
7049         struct GNUNET_TIME_Absolute start;
7050         struct GNUNET_TIME_Relative creation;
7051         struct GNUNET_TIME_Relative solving;
7052         char *text = "unmodified";
7053
7054         struct GNUNET_TIME_Relative delta = GNUNET_TIME_absolute_get_difference (ats->last, GNUNET_TIME_absolute_get());
7055         if (delta.rel_value < ats->min_delta.rel_value)
7056         {
7057 #if DEBUG_ATS
7058                 GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Minimum time between cycles not reached\n");
7059 #endif
7060                 return;
7061         }
7062
7063         int dur = 500;
7064         if (INT_MAX < ats->max_exec_duration.rel_value)
7065                 dur = INT_MAX;
7066         else
7067                 dur = (int) ats->max_exec_duration.rel_value;
7068
7069         ats->stat.simplex_rerun_required = GNUNET_NO;
7070         start = GNUNET_TIME_absolute_get();
7071         if ((ats->stat.recreate_problem == GNUNET_YES) || (ats->prob==NULL) || (ats->stat.valid == GNUNET_NO))
7072         {
7073                 text = "new";
7074                 ats->stat.recreate_problem = GNUNET_YES;
7075                 ats_delete_problem ();
7076                 ats_create_problem (ats->D, ats->U, ats->R, ats->v_b_min, ats->v_n_min, &ats->stat);
7077 #if DEBUG_ATS
7078                 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);
7079 #endif
7080         }
7081
7082         else if ((ats->stat.recreate_problem == GNUNET_NO) && (ats->stat.modified_resources == GNUNET_YES) && (ats->stat.valid == GNUNET_YES))
7083         {
7084                 text = "modified resources";
7085                 ats_update_problem_cr();
7086         }
7087         else if ((ats->stat.recreate_problem == GNUNET_NO) && (ats->stat.modified_quality == GNUNET_YES) && (ats->stat.valid == GNUNET_YES))
7088         {
7089                 text = "modified quality";
7090                 ats_update_problem_qm();
7091                 //ats_update_problem_qm_TEST ();
7092
7093         }
7094 #if DEBUG_ATS
7095         else GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem is unmodified\n");
7096 #endif
7097
7098         creation = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
7099         start = GNUNET_TIME_absolute_get();
7100
7101         ats->stat.solution = GLP_UNDEF;
7102         if (ats->stat.valid == GNUNET_YES)
7103         {
7104                 ats_solve_problem(ats->max_iterations, ats->max_exec_duration.rel_value, ats->stat.c_peers, ats->stat.c_mechs, &ats->stat);
7105         }
7106         solving = GNUNET_TIME_absolute_get_difference(start,GNUNET_TIME_absolute_get());
7107
7108         if (ats->stat.valid == GNUNET_YES)
7109         {
7110                 int msg_type = GNUNET_ERROR_TYPE_DEBUG;
7111 #if DEBUG_ATS
7112                 msg_type = GNUNET_ERROR_TYPE_ERROR;
7113 #endif
7114                 GNUNET_log (msg_type, "MLP %s: creation time: %llu, execution time: %llu, %i mechanisms, simplex rerun: %s, solution %s\n",
7115                                 text, creation.rel_value, solving.rel_value,
7116                                 ats->stat.c_mechs,
7117                                 (ats->stat.simplex_rerun_required == GNUNET_NO) ? "NO" : "YES", (ats->stat.solution == 5) ? "OPTIMAL" : "INVALID");
7118                 ats->successful_executions ++;
7119                 GNUNET_STATISTICS_set (stats, "# ATS successful executions", ats->successful_executions, GNUNET_NO);
7120
7121                 if ((ats->stat.recreate_problem == GNUNET_YES) || (ats->prob==NULL))
7122                         GNUNET_STATISTICS_set (stats, "ATS state",ATS_NEW, GNUNET_NO);
7123                 else if ((ats->stat.modified_resources == GNUNET_YES) &&
7124                                 (ats->stat.modified_quality == GNUNET_NO))
7125                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_C_UPDATED, GNUNET_NO);
7126                 else if ((ats->stat.modified_resources == GNUNET_NO) &&
7127                                 (ats->stat.modified_quality == GNUNET_YES) &&
7128                                 (ats->stat.simplex_rerun_required == GNUNET_NO))
7129                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_Q_UPDATED, GNUNET_NO);
7130                 else if ((ats->stat.modified_resources == GNUNET_YES) &&
7131                                 (ats->stat.modified_quality == GNUNET_YES) &&
7132                                 (ats->stat.simplex_rerun_required == GNUNET_NO))
7133                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_QC_UPDATED, GNUNET_NO);
7134                 else if (ats->stat.simplex_rerun_required == GNUNET_NO)
7135                         GNUNET_STATISTICS_set (stats, "ATS state", ATS_UNMODIFIED, GNUNET_NO);
7136         }
7137         else
7138         {
7139                 if (ats->stat.c_peers != 0)
7140                 {
7141                         ats->invalid_executions ++;
7142                         GNUNET_STATISTICS_set (stats, "# ATS invalid executions", ats->invalid_executions, GNUNET_NO);
7143                 }
7144                 else
7145                 {
7146                         GNUNET_STATISTICS_set (stats, "# ATS successful executions", ats->successful_executions, GNUNET_NO);
7147                 }
7148         }
7149
7150         GNUNET_STATISTICS_set (stats, "ATS duration", solving.rel_value + creation.rel_value, GNUNET_NO);
7151         GNUNET_STATISTICS_set (stats, "ATS mechanisms", ats->stat.c_mechs, GNUNET_NO);
7152         GNUNET_STATISTICS_set (stats, "ATS peers", ats->stat.c_peers, GNUNET_NO);
7153         GNUNET_STATISTICS_set (stats, "ATS solution", ats->stat.solution, GNUNET_NO);
7154         GNUNET_STATISTICS_set (stats, "ATS timestamp", start.abs_value, GNUNET_NO);
7155
7156         if ((ats->save_mlp == GNUNET_YES) && (ats->stat.c_mechs >= ats->dump_min_peers) && (ats->stat.c_mechs >= ats->dump_min_addr))
7157         {
7158                 char * filename;
7159                 if (ats->dump_overwrite == GNUNET_NO)
7160                 {
7161                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.mlp",
7162                         ats->stat.c_peers, ats->stat.c_mechs, text, GNUNET_TIME_absolute_get().abs_value);
7163                         glp_write_lp (ats->prob, NULL, filename);
7164                 }
7165                 else
7166                 {
7167                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.mlp",
7168                         ats->stat.c_peers, ats->stat.c_mechs );
7169                         glp_write_lp (ats->prob, NULL, filename);
7170                 }
7171                 GNUNET_free (filename);
7172         }
7173         if ((ats->save_solution == GNUNET_YES) && (ats->stat.c_mechs >= ats->dump_min_peers) && (ats->stat.c_mechs >= ats->dump_min_addr))
7174         {
7175                 char * filename;
7176                 if (ats->dump_overwrite == GNUNET_NO)
7177                 {
7178                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i_%s_%llu.sol",
7179                         ats->stat.c_peers, ats->stat.c_mechs, text, GNUNET_TIME_absolute_get().abs_value);
7180                         glp_print_sol (ats->prob, filename);
7181                 }
7182                 else
7183                 {
7184                         GNUNET_asprintf (&filename, "ats_mlp_p%i_m%i.sol",
7185                         ats->stat.c_peers, ats->stat.c_mechs);
7186                         glp_print_sol (ats->prob, filename);
7187                 }
7188                 GNUNET_free (filename);
7189         }
7190
7191         ats->last = GNUNET_TIME_absolute_get();
7192         ats->stat.recreate_problem = GNUNET_NO;
7193         ats->stat.modified_resources = GNUNET_NO;
7194         ats->stat.modified_quality = GNUNET_NO;
7195 #endif
7196 }
7197
7198 static void
7199 ats_schedule_calculation (void *cls,
7200                           const struct GNUNET_SCHEDULER_TaskContext *tc)
7201 {
7202         struct ATS_info *ats = (struct ATS_info *) cls;
7203         if (ats==NULL) return;
7204
7205         ats->ats_task = GNUNET_SCHEDULER_NO_TASK;
7206         if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
7207             return;
7208
7209 #if DEBUG_ATS
7210         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Running scheduled calculation\n");
7211 #endif
7212
7213         ats_calculate_bandwidth_distribution (ats);
7214
7215         ats->ats_task = GNUNET_SCHEDULER_add_delayed (ats->exec_interval,
7216                                         &ats_schedule_calculation, ats);
7217 }
7218
7219 void ats_init ()
7220 {
7221         int c = 0;
7222         unsigned long long  value;
7223         char * section;
7224
7225         ats = GNUNET_malloc(sizeof (struct ATS_info));
7226
7227         ats->min_delta = ATS_MIN_INTERVAL;
7228         ats->exec_interval = ATS_EXEC_INTERVAL;
7229         ats->max_exec_duration = ATS_MAX_EXEC_DURATION;
7230         ats->max_iterations = ATS_MAX_ITERATIONS;
7231         ats->ats_task = GNUNET_SCHEDULER_NO_TASK;
7232
7233 #if !HAVE_LIBGLPK
7234         GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "GLPK not installed, ATS not active\n");
7235         return;
7236 #endif
7237
7238         ats->D = 1.0;
7239         ats->U = 1.0;
7240         ats->R = 1.0;
7241         ats->v_b_min = 64000;
7242         ats->v_n_min = 10;
7243         ats->dump_min_peers = 1;
7244         ats->dump_min_addr = 1;
7245         ats->dump_overwrite = GNUNET_NO;
7246         ats->mechanisms = NULL;
7247         ats->peers = NULL;
7248         ats->successful_executions = 0;
7249         ats->invalid_executions = 0;
7250
7251 #if HAVE_LIBGLPK
7252         ats->prob = NULL;
7253 #endif
7254
7255         /* loading cost ressources */
7256         for (c=0; c<available_ressources; c++)
7257         {
7258                 GNUNET_asprintf(&section,"%s_UP",ressources[c].cfg_param);
7259                 if (GNUNET_CONFIGURATION_have_value(cfg, "transport", section))
7260                 {
7261                         if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "transport",section, &value))
7262                         {
7263 #if DEBUG_ATS
7264                                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Found ressource cost: [%s] = %llu\n", section, value);
7265 #endif
7266                                 ressources[c].c_max = value;
7267                         }
7268                 }
7269                 GNUNET_free (section);
7270                 GNUNET_asprintf(&section,"%s_DOWN",ressources[c].cfg_param);
7271                 if (GNUNET_CONFIGURATION_have_value(cfg, "transport", section))
7272                 {
7273                         if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "transport",section, &value))
7274                         {
7275 #if DEBUG_ATS
7276                                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Found ressource cost: [%s] = %llu\n", section, value);
7277 #endif
7278                                 ressources[c].c_min = value;
7279                         }
7280                 }
7281                 GNUNET_free (section);
7282         }
7283
7284         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_MLP"))
7285                 ats->save_mlp = GNUNET_CONFIGURATION_get_value_yesno (cfg, "transport","DUMP_MLP");
7286
7287         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_SOLUTION"))
7288                 ats->save_solution = GNUNET_CONFIGURATION_get_value_yesno (cfg, "transport","DUMP_SOLUTION");
7289         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_OVERWRITE"))
7290                 ats->dump_overwrite = GNUNET_CONFIGURATION_get_value_yesno (cfg, "transport","DUMP_OVERWRITE");
7291         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_MIN_PEERS"))
7292         {
7293                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","DUMP_MIN_PEERS", &value);
7294                 ats->dump_min_peers= value;
7295         }
7296         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_MIN_ADDRS"))
7297         {
7298                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","DUMP_MIN_ADDRS", &value);
7299                 ats->dump_min_addr= value;
7300         }
7301         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "DUMP_OVERWRITE"))
7302         {
7303                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","DUMP_OVERWRITE", &value);
7304                 ats->min_delta.rel_value = value;
7305         }
7306
7307         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "ATS_MIN_INTERVAL"))
7308         {
7309                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","ATS_MIN_INTERVAL", &value);
7310                 ats->min_delta.rel_value = value;
7311         }
7312
7313         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "ATS_EXEC_INTERVAL"))
7314         {
7315                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","ATS_EXEC_INTERVAL", &value);
7316                 ats->exec_interval.rel_value = value;
7317         }
7318         if (GNUNET_CONFIGURATION_have_value(cfg, "transport", "ATS_MIN_INTERVAL"))
7319         {
7320                 GNUNET_CONFIGURATION_get_value_number(cfg, "transport","ATS_MIN_INTERVAL", &value);
7321                 ats->min_delta.rel_value = value;
7322         }
7323
7324         ats->ats_task = GNUNET_SCHEDULER_add_now(&ats_schedule_calculation, ats);
7325 }
7326
7327
7328 static void ats_shutdown ()
7329 {
7330 #if DEBUG_ATS
7331         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ats_destroy\n");
7332 #endif
7333         if (ats->ats_task != GNUNET_SCHEDULER_NO_TASK)
7334                 GNUNET_SCHEDULER_cancel(ats->ats_task);
7335         ats->ats_task = GNUNET_SCHEDULER_NO_TASK;
7336
7337 #if HAVE_LIBGLPK
7338         ats_delete_problem ();
7339         glp_free_env();
7340 #endif
7341         GNUNET_free (ats);
7342 }
7343
7344
7345 void ats_notify_peer_connect (
7346                 const struct GNUNET_PeerIdentity *peer,
7347                 const struct GNUNET_TRANSPORT_ATS_Information *ats_data, int ats_count)
7348 {
7349 #if DEBUG_ATS
7350         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ats_notify_peer_connect: %s\n",GNUNET_i2s(peer));
7351 #endif
7352         //update_addr_ats();
7353         ats->stat.recreate_problem = GNUNET_YES;
7354         ats_calculate_bandwidth_distribution(ats);
7355 }
7356
7357 void ats_notify_peer_disconnect (
7358                 const struct GNUNET_PeerIdentity *peer)
7359 {
7360 #if DEBUG_ATS
7361         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ats_notify_peer_disconnect: %s\n",GNUNET_i2s(peer));
7362 #endif
7363         ats->stat.recreate_problem = GNUNET_YES;
7364         ats_calculate_bandwidth_distribution (ats);
7365 }
7366
7367 struct ForeignAddressList * ats_get_preferred_address (
7368                 struct NeighbourList *n)
7369 {
7370 #if DEBUG_ATS
7371         //GNUNET_log (GNUNET_ERROR_TYPE_BULK, "ats_get_prefered_transport for peer: %s\n",GNUNET_i2s(&n->id));
7372 #endif
7373         struct ReadyList *next = n->plugins;
7374         while (next != NULL)
7375         {
7376 #if DEBUG_ATS
7377                 //GNUNET_log (GNUNET_ERROR_TYPE_BULK, "plugin: %s %i\n",next->plugin->short_name,strcmp(next->plugin->short_name,"unix"));
7378 #endif
7379                 next = next->next;
7380         }
7381         return find_ready_address(n);
7382 }
7383
7384 /**
7385  * Initiate transport service.
7386  *
7387  * @param cls closure
7388  * @param server the initialized server
7389  * @param c configuration to use
7390  */
7391 static void
7392 run (void *cls,
7393      struct GNUNET_SERVER_Handle *server,
7394      const struct GNUNET_CONFIGURATION_Handle *c)
7395 {
7396   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
7397     {&handle_start, NULL,
7398      GNUNET_MESSAGE_TYPE_TRANSPORT_START, sizeof (struct StartMessage)},
7399     {&handle_hello, NULL,
7400      GNUNET_MESSAGE_TYPE_HELLO, 0},
7401     {&handle_send, NULL,
7402      GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0},
7403     {&handle_request_connect, NULL,
7404      GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT, sizeof(struct TransportRequestConnectMessage)},
7405     {&handle_set_quota, NULL,
7406      GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA, sizeof (struct QuotaSetMessage)},
7407     {&handle_address_lookup, NULL,
7408      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_LOOKUP,
7409      0},
7410     {&handle_blacklist_init, NULL,
7411      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, sizeof (struct GNUNET_MessageHeader)},
7412     {&handle_blacklist_reply, NULL,
7413      GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, sizeof (struct BlacklistMessage)},
7414     {NULL, NULL, 0, 0}
7415   };
7416   char *plugs;
7417   char *pos;
7418   int no_transports;
7419   unsigned long long tneigh;
7420   char *keyfile;
7421
7422   cfg = c;
7423   stats = GNUNET_STATISTICS_create ("transport", cfg);
7424   validation_map = GNUNET_CONTAINER_multihashmap_create (64);
7425   /* parse configuration */
7426   if ((GNUNET_OK !=
7427        GNUNET_CONFIGURATION_get_value_number (c,
7428                                               "TRANSPORT",
7429                                               "NEIGHBOUR_LIMIT",
7430                                               &tneigh)) ||
7431       (GNUNET_OK !=
7432        GNUNET_CONFIGURATION_get_value_filename (c,
7433                                                 "GNUNETD",
7434                                                 "HOSTKEY", &keyfile)))
7435     {
7436       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7437                   _
7438                   ("Transport service is lacking key configuration settings.  Exiting.\n"));
7439       GNUNET_SCHEDULER_shutdown ();
7440       if (stats != NULL)
7441         {
7442           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
7443           stats = NULL;
7444         }
7445       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
7446       validation_map = NULL;
7447       return;
7448     }
7449
7450   max_connect_per_transport = (uint32_t) tneigh;
7451   peerinfo = GNUNET_PEERINFO_connect (cfg);
7452   if (peerinfo == NULL)
7453     {
7454       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7455                   _("Could not access PEERINFO service.  Exiting.\n"));
7456       GNUNET_SCHEDULER_shutdown ();
7457       if (stats != NULL)
7458         {
7459           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
7460           stats = NULL;
7461         }
7462       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
7463       validation_map = NULL;
7464       GNUNET_free (keyfile);
7465       return;
7466     }
7467   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
7468   GNUNET_free (keyfile);
7469   if (my_private_key == NULL)
7470     {
7471       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
7472                   _
7473                   ("Transport service could not access hostkey.  Exiting.\n"));
7474       GNUNET_SCHEDULER_shutdown ();
7475       if (stats != NULL)
7476         {
7477           GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
7478           stats = NULL;
7479         }
7480       GNUNET_CONTAINER_multihashmap_destroy (validation_map);
7481       validation_map = NULL;
7482       return;
7483     }
7484   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
7485   GNUNET_CRYPTO_hash (&my_public_key,
7486                       sizeof (my_public_key), &my_identity.hashPubKey);
7487   /* setup notification */
7488   GNUNET_SERVER_disconnect_notify (server,
7489                                    &client_disconnect_notification, NULL);
7490   /* load plugins... */
7491   no_transports = 1;
7492   if (GNUNET_OK ==
7493       GNUNET_CONFIGURATION_get_value_string (c,
7494                                              "TRANSPORT", "PLUGINS", &plugs))
7495     {
7496       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
7497                   _("Starting transport plugins `%s'\n"), plugs);
7498       pos = strtok (plugs, " ");
7499       while (pos != NULL)
7500         {
7501           start_transport (server, pos);
7502           no_transports = 0;
7503           pos = strtok (NULL, " ");
7504         }
7505       GNUNET_free (plugs);
7506     }
7507   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
7508                                 &shutdown_task, NULL);
7509   if (no_transports)
7510     refresh_hello ();
7511
7512   ats_init();
7513
7514 #if DEBUG_TRANSPORT
7515   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transport service ready.\n"));
7516 #endif
7517   /* If we have a blacklist file, read from it */
7518   read_blacklist_file(cfg);
7519   /* process client requests */
7520   GNUNET_SERVER_add_handlers (server, handlers);
7521 }
7522
7523
7524 /**
7525  * The main function for the transport service.
7526  *
7527  * @param argc number of arguments from the command line
7528  * @param argv command line arguments
7529  * @return 0 ok, 1 on error
7530  */
7531 int
7532 main (int argc, char *const *argv)
7533 {
7534   a2s (NULL, NULL, 0); /* make compiler happy */
7535   return (GNUNET_OK ==
7536           GNUNET_SERVICE_run (argc,
7537                               argv,
7538                               "transport",
7539                               GNUNET_SERVICE_OPTION_NONE,
7540                               &run, NULL)) ? 0 : 1;
7541 }
7542
7543 /* end of gnunet-service-transport.c */