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