src/include/gnunet_ats_service.h

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010,2011 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  * @file include/gnunet_ats_service.h
  22  * @brief automatic transport selection and outbound bandwidth determination
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25  */
  26 #ifndef GNUNET_ATS_SERVICE_H
  27 #define GNUNET_ATS_SERVICE_H
  28
  29 #include "gnunet_constants.h"
  30 #include "gnunet_util_lib.h"
  31 #include "gnunet_hello_lib.h"
  32
  33
  34 enum GNUNET_ATS_Network_Type
  35 {
  36   GNUNET_ATS_NET_UNSPECIFIED = 0,
  37   GNUNET_ATS_NET_LOOPBACK = 1,
  38   GNUNET_ATS_NET_LAN = 2,
  39   GNUNET_ATS_NET_WAN = 3,
  40   GNUNET_ATS_NET_WLAN = 4,
  41 };
  42
  43 /**
  44  * Enum defining all known property types for ATS Enum values are used
  45  * in the GNUNET_ATS_Information struct as
  46  * (key,value)-pairs.
  47  *
  48  * Cost are always stored in uint32_t, so all units used to define costs
  49  * have to be normalized to fit in uint32_t [0 .. 4.294.967.295]
  50  */
  51 enum GNUNET_ATS_Property
  52 {
  53
  54   /**
  55    * End of the array.
  56    * @deprecated
  57    */
  58   GNUNET_ATS_ARRAY_TERMINATOR = 0,
  59
  60   /**
  61    * Actual traffic on this connection from the other peer to this peer.
  62    *
  63    * Unit: [bytes/second]
  64    */
  65   GNUNET_ATS_UTILIZATION_UP,
  66
  67   /**
  68    * Actual traffic on this connection from this peer to the other peer.
  69    *
  70    * Unit: [bytes/second]
  71    */
  72   GNUNET_ATS_UTILIZATION_DOWN,
  73
  74   /**
  75    * Is this address located in WAN, LAN or a loopback address
  76    * Value is element of GNUNET_ATS_Network_Type
  77    */
  78   GNUNET_ATS_NETWORK_TYPE,
  79
  80   /**
  81    * Delay
  82    * Time between when the time packet is sent and the packet arrives
  83    *
  84    * Unit: [ms]
  85    *
  86    * Examples:
  87    *
  88    * LAN   :    1
  89    * WLAN  :    2
  90    * Dialup:  500
  91    */
  92   GNUNET_ATS_QUALITY_NET_DELAY,
  93
  94   /**
  95    * Distance on network layer (required for distance-vector routing).
  96    *
  97    * Unit: [DV-hops]
  98    */
  99   GNUNET_ATS_QUALITY_NET_DISTANCE,
 100
 101   /**
 102    * Network overhead on WAN (Wide-Area Network)
 103    *
 104    * How many bytes are sent on the WAN when 1 kilobyte (1024 bytes)
 105    * of application data is transmitted?
 106    * A factor used with connect cost, bandwidth cost and energy cost
 107    * to describe the overhead produced by the transport protocol
 108    *
 109    * Unit: [bytes/kb]
 110    *
 111    * Interpretation: less is better
 112    *
 113    * Examples:
 114    *
 115    * TCP/IPv4 over Ethernet: 1024 + 38 + 20 + 20 = 1102 [bytes/kb]
 116    * TCP/IPv6 over Ethernet: 1024 + 38 + 20 + 40 = 1122 [bytes/kb]
 117    * UDP/IPv4 over Ethernet: 1024 + 38 + 20 + 8  = 1090 [bytes/kb]
 118    * UDP/IPv6 over Ethernet: 1024 + 38 + 40 + 8  = 1110 [bytes/kb]
 119    */
 120   GNUNET_ATS_COST_WAN,
 121
 122   /**
 123    * Network overhead on LAN (Local-Area Network)
 124    *
 125    * How many bytes are sent on the LAN when 1 kilobyte (1024 bytes)
 126    * of application data is transmitted?
 127    * A factor used with connect cost, bandwidth cost and energy cost
 128    * to describe the overhead produced by the transport protocol
 129    *
 130    * Unit: [bytes/kb]
 131    *
 132    * Interpretation: less is better
 133    *
 134    * Examples:
 135    *
 136    * TCP/IPv4 over Ethernet: 1024 + 38 + 20 + 20 = 1102 [bytes/kb]
 137    * TCP/IPv6 over Ethernet: 1024 + 38 + 20 + 40 = 1122 [bytes/kb]
 138    * UDP/IPv4 over Ethernet: 1024 + 38 + 20 + 8  = 1090 [bytes/kb]
 139    * UDP/IPv6 over Ethernet: 1024 + 38 + 40 + 8  = 1110 [bytes/kb]
 140    */
 141   GNUNET_ATS_COST_LAN,
 142
 143   /**
 144    * Network overhead on WLAN (Wireless Local Area Network)
 145    *
 146    * How many bytes are sent on the LAN when 1 kilobyte (1024 bytes)
 147    * of application data is transmitted?
 148    * A factor used with connect cost, bandwidth cost and energy cost
 149    * to describe the overhead produced by the transport protocol
 150    *
 151    * Unit: [bytes/kb]
 152    *
 153    * Interpretation: less is better
 154    *
 155    * Examples:
 156    *
 157    * TCP/IPv4 over Ethernet: 1024 + 38 + 20 + 20 = 1102 [bytes/kb]
 158    * TCP/IPv6 over Ethernet: 1024 + 38 + 20 + 40 = 1122 [bytes/kb]
 159    * UDP/IPv4 over Ethernet: 1024 + 38 + 20 + 8  = 1090 [bytes/kb]
 160    * UDP/IPv6 over Ethernet: 1024 + 38 + 40 + 8  = 1110 [bytes/kb]
 161    */
 162   GNUNET_ATS_COST_WLAN
 163       /* Cost related values */
 164       /* =================== */
 165   /**
 166    * Volume based cost in financial units to transmit data
 167    *
 168    * Note: This value is not bound to a specific currency or unit and only
 169    * used locally.
 170    * "cent" just refers the smallest amount of money in the respective
 171    * currency.
 172    *
 173    * Unit: [cent/MB]
 174    *
 175    * Interpretation: less is better
 176    *
 177    * Examples:
 178    * LAN:  0 [cent/MB]
 179    * 2G : 10 [cent/MB]
 180    */
 181       // GNUNET_ATS_COST_FINANCIAL_PER_VOLUME = 1,
 182   /**
 183    * Time based cost in financial units to transmit data
 184    *
 185    * Note: This value is not bound to a specific currency or unit and only
 186    * used locally.
 187    * "cent" just refers the smallest amount of money in the respective
 188    * currency.
 189    *
 190    * Unit: [cent/h]
 191    *
 192    * Interpretation: less is better
 193    *
 194    * Examples:
 195    * LAN   :  0 [cent/h]
 196    * Dialup: 10 [cent/h]
 197    */
 198       // GNUNET_ATS_COST_FINANCIAL_PER_TIME = 2,
 199   /**
 200    * Computational costs
 201    *
 202    * Effort of preparing data to be sent with this transport
 203    * Includes encoding, encryption and conversion of data
 204    * Partial values can be summed up: c_sum = c_enc + c_enc + c_conv
 205    * Resulting values depend on local system properties, e.g. CPU
 206    *
 207    * Unit: [ms/GB]
 208    *
 209    * Interpretation: less is better
 210    *
 211    * Examples:
 212    *
 213    * HTTPS with AES CBC-256:    7,382
 214    * HTTPS with AES CBC-128:    5,279
 215    * HTTPS with RC4-1024:       2,652
 216    */
 217       // GNUNET_ATS_COST_COMPUTATIONAL = 3,
 218   /**
 219    * Energy consumption
 220    *
 221    * Energy consumption using this transport when sending with a certain
 222    * power at a certain bitrate. This is only an approximation based on:
 223    * Energy consumption E = P / D
 224    *
 225    * with:
 226    * Power P in Watt (J/s)
 227    * Datarate D in MBit/s
 228    *
 229    * Conversion between power P and dBm used by WLAN in radiotap's dBm TX power:
 230    *
 231    * Lp(dbm) = 10 log10 (P/ 1mW)
 232    *
 233    * => P = 1 mW  * 10^(Lp(dbm)/10)
 234    *
 235    * Unit: [mJ/MB]
 236    *
 237    * Interpretation: less is better
 238    *
 239    * Examples:
 240    *
 241    * LAN:       0
 242    * WLAN:      89 (600 mW @ 802.11g /w 54 MBit/s)
 243    * Bluetooth: 267 (100 mW @ BT2.0 EDR /w 3 MBit/s)
 244    */
 245       // GNUNET_ATS_COST_ENERGY_CONSUMPTION = 4,
 246   /**
 247    * Connect cost
 248    * How many bytes are transmitted to initiate a new connection using
 249    * this transport?
 250    *
 251    * Unit: [bytes]
 252    *
 253    * Interpretation: less is better
 254    *
 255    * Examples:
 256    *
 257    * UDP (No connection)      :
 258    *     0 bytes
 259    * TCP (TCP 3-Way handshake):
 260    *   220 bytes Ethernet,  172 bytes TCP/IP,  122 bytes TCP
 261    * HTTP (TCP + Header)      :
 262    *   477 bytes Ethernet,  429 bytes TCP/IP,  374 bytes TCP,  278 bytes HTTP
 263    * HTTPS  HTTP+TLS Handshake:
 264    *  2129 bytes Ethernet, 1975 bytes TCP/IP, 1755 bytes TCP, 1403 bytes HTTPS
 265    *
 266    * */
 267       // GNUNET_ATS_COST_CONNECT = 5,
 268   /**
 269    * Bandwidth cost
 270    *
 271    * How many bandwidth is available to consume?
 272    * Used to calculate which impact sending data with this transport has
 273    *
 274    * Unit: [kB/s]
 275    *
 276    * Interpretation: more is better
 277    *
 278    * Examples:
 279    * LAN:     12,800  (100 MBit/s)
 280    * WLAN:    6,912   (54 MBit/s)
 281    * Dial-up: 8       (64 Kbit/s)
 282    *
 283    */
 284       // GNUNET_ATS_COST_BANDWITH_AVAILABLE = 6,
 285   /**
 286    *  Network overhead
 287    *
 288    * How many bytes are sent over the wire when 1 kilobyte (1024 bytes)
 289    * of application data is transmitted?
 290    * A factor used with connect cost, bandwidth cost and energy cost
 291    * to describe the overhead produced by the transport protocol
 292    *
 293    * Unit: [bytes/kb]
 294    *
 295    * Interpretation: less is better
 296    *
 297    * Examples:
 298    *
 299    * TCP/IPv4 over Ethernet: 1024 + 38 + 20 + 20 = 1102 [bytes/kb]
 300    * TCP/IPv6 over Ethernet: 1024 + 38 + 20 + 40 = 1122 [bytes/kb]
 301    * UDP/IPv4 over Ethernet: 1024 + 38 + 20 + 8  = 1090 [bytes/kb]
 302    * UDP/IPv6 over Ethernet: 1024 + 38 + 40 + 8  = 1110 [bytes/kb]
 303    */
 304       // GNUNET_ATS_COST_NETWORK_OVERHEAD = 7,
 305       /* Quality related values */
 306       /* ====================== */
 307       /* Physical layer quality properties */
 308   /**
 309    * Signal strength on physical layer
 310    *
 311    * Unit: [dBm]
 312    */
 313       // GNUNET_ATS_QUALITY_PHY_SIGNAL_STRENGTH = 1025,
 314   /**
 315    * Collision rate on physical layer
 316    *
 317    * Unit: [B/s]
 318    */
 319       // GNUNET_ATS_QUALITY_PHY_COLLISION_RATE = 1026,
 320   /**
 321    * Error rate on physical layer
 322    *
 323    * Unit: [B/s]
 324    */
 325       // GNUNET_ATS_QUALITY_PHY_ERROR_RATE = 1027,
 326   /**
 327    * Jitter
 328    * Time variations of the delay
 329    * 1st derivative of a delay function
 330    *
 331    * Unit: [ms]
 332    */
 333       // GNUNET_ATS_QUALITY_NET_JITTER = 1029,
 334   /**
 335    * Error rate on network layer
 336    *
 337    * Unit: [B/s]
 338    *
 339    * Examples:
 340    *
 341    * LAN       :    0
 342    * WLAN      :  400
 343    * Bluetooth :  100
 344    * Note: This numbers are just assumptions as an example, not
 345    * measured or somehow determined
 346    */
 347       // GNUNET_ATS_QUALITY_NET_ERRORRATE = 1030,
 348   /**
 349    * Drop rate on network layer
 350    * Bytes actively dismissed by a network component during transmission
 351    * Reasons for dropped data can be full queues, congestion, quota violations...
 352    *
 353    * Unit: [B/s]
 354    *
 355    * Examples:
 356    *
 357    * LAN       :    0
 358    * WLAN      :  400
 359    * Bluetooth :  100
 360    * Note: This numbers are just assumptions as an example, not
 361    * measured or somehow determined
 362    */
 363       // GNUNET_ATS_QUALITY_NET_DROPRATE = 1031,
 364   /**
 365    * Loss rate on network layer
 366    * Bytes lost during transmission
 367    * Reasons can be collisions, ...
 368    *
 369    * Unit: [B/s]
 370    *
 371    * Examples:
 372    *
 373    * LAN       :    0
 374    * WLAN      :   40
 375    * Bluetooth :   10
 376    * Note: This numbers are just assumptions as an example, not measured
 377    * or somehow determined
 378    */
 379       // GNUNET_ATS_QUALITY_NET_LOSSRATE = 1032,
 380   /**
 381    * Throughput on network layer
 382    *
 383    * Unit: [kB/s]
 384    *
 385    * Examples:
 386    *
 387    * LAN   : 3400
 388    * WLAN  : 1200
 389    * Dialup:      4
 390    *
 391    */
 392       // GNUNET_ATS_QUALITY_NET_THROUGHPUT = 1033,
 393       /* Availability related values */
 394       /* =========================== */
 395   /**
 396    * Is a peer reachable?
 397    */
 398       // GNUNET_ATS_AVAILABILITY_REACHABLE = 2048,
 399   /**
 400    * Is there a connection established to a peer using this transport
 401    */
 402       // GNUNET_ATS_AVAILABILITY_CONNECTED = 2049
 403 };
 404
 405
 406 GNUNET_NETWORK_STRUCT_BEGIN
 407
 408 /**
 409  * struct used to communicate the transport's properties like cost and
 410  * quality of service as well as high-level constraints on resource
 411  * consumption.
 412  *
 413  *                             +---+
 414  *  +-----------+ Constraints  |   |  Plugin properties +---------+
 415  *  | Highlevel |------------> |ATS| <------------------|Transport|
 416  *  | Component | ATS struct   |   |    ATS struct      | Plugin  |
 417  *  +-----------+              |   |                    +---------+
 418  *                             +---+
 419  *
 420  * This structure will be used by transport plugins to communicate
 421  * costs to ATS or by higher level components to tell ATS their
 422  * constraints.  Always a pair of (GNUNET_ATS_Property,
 423  * uint32_t value).  Value is always uint32_t, so all units used to
 424  * define costs have to be normalized to fit uint32_t.
 425  */
 426 struct GNUNET_ATS_Information
 427 {
 428   /**
 429    * ATS property type, in network byte order.
 430    */
 431   uint32_t type GNUNET_PACKED;
 432
 433   /**
 434    * ATS property value, in network byte order.
 435    */
 436   uint32_t value GNUNET_PACKED;
 437 };
 438 GNUNET_NETWORK_STRUCT_END
 439
 440
 441 /* ******************************** Scheduling API ***************************** */
 442
 443 /**
 444  * Handle to the ATS subsystem for bandwidth/transport scheduling information.
 445  */
 446 struct GNUNET_ATS_SchedulingHandle;
 447
 448
 449 /**
 450  * Opaque session handle, defined by plugins.  Contents not known to ATS.
 451  */
 452 struct Session;
 453
 454
 455 /**
 456  * Signature of a function called by ATS with the current bandwidth
 457  * and address preferences as determined by ATS.
 458  *
 459  * @param cls closure
 460  * @param address suggested address (including peer identity of the peer)
 461  * @param session session to use
 462  * @param bandwidth_out assigned outbound bandwidth for the connection
 463  * @param bandwidth_in assigned inbound bandwidth for the connection
 464  * @param ats performance data for the address (as far as known)
 465  * @param ats_count number of performance records in 'ats'
 466  */
 467 typedef void (*GNUNET_ATS_AddressSuggestionCallback) (void *cls,
 468                                                       const struct
 469                                                       GNUNET_HELLO_Address *
 470                                                       address,
 471                                                       struct Session * session,
 472                                                       struct
 473                                                       GNUNET_BANDWIDTH_Value32NBO
 474                                                       bandwidth_out,
 475                                                       struct
 476                                                       GNUNET_BANDWIDTH_Value32NBO
 477                                                       bandwidth_in,
 478                                                       const struct
 479                                                       GNUNET_ATS_Information *
 480                                                       ats, uint32_t ats_count);
 481
 482
 483 /**
 484  * Initialize the ATS subsystem.
 485  *
 486  * @param cfg configuration to use
 487  * @param suggest_cb notification to call whenever the suggestation changed
 488  * @param suggest_cb_cls closure for 'suggest_cb'
 489  * @return ats context
 490  */
 491 struct GNUNET_ATS_SchedulingHandle *
 492 GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
 493                             GNUNET_ATS_AddressSuggestionCallback suggest_cb,
 494                             void *suggest_cb_cls);
 495
 496
 497 /**
 498  * Client is done with ATS scheduling, release resources.
 499  *
 500  * @param sh handle to release
 501  */
 502 void
 503 GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh);
 504
 505
 506 /**
 507  * We would like to establish a new connection with a peer.  ATS
 508  * should suggest a good address to begin with.
 509  *
 510  * @param sh handle
 511  * @param peer identity of the peer we need an address for
 512  */
 513 void
 514 GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *sh,
 515                             const struct GNUNET_PeerIdentity *peer);
 516
 517
 518 /**
 519  * We want to cancel ATS suggesting addresses for a peer.
 520  *
 521  * @param sh handle
 522  * @param peer identity of the peer
 523  */
 524 void
 525 GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
 526                                    const struct GNUNET_PeerIdentity *peer);
 527
 528
 529 /**
 530  * Returns where the address is located: LAN or WAN or ...
 531  * @param addr address
 532  * @param addrlen address length
 533  * @return location as GNUNET_ATS_Information
 534  */
 535 struct GNUNET_ATS_Information
 536 GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle *sh,
 537                              const struct sockaddr * addr,
 538                              socklen_t addrlen);
 539
 540
 541 /**
 542  * We have updated performance statistics for a given address.  Note
 543  * that this function can be called for addresses that are currently
 544  * in use as well as addresses that are valid but not actively in use.
 545  * Furthermore, the peer may not even be connected to us right now (in
 546  * which case the call may be ignored or the information may be stored
 547  * for later use).  Update bandwidth assignments.
 548  *
 549  * @param sh handle
 550  * @param address updated address
 551  * @param session session handle (if available)
 552  * @param ats performance data for the address
 553  * @param ats_count number of performance records in 'ats'
 554  */
 555 void
 556 GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
 557                            const struct GNUNET_HELLO_Address *address,
 558                            struct Session *session,
 559                            const struct GNUNET_ATS_Information *ats,
 560                            uint32_t ats_count);
 561
 562
 563 /**
 564  * An address is now in use or not used any more.
 565  *
 566  * @param sh handle
 567  * @param address the address
 568  * @param session session handle
 569  * @param in_use GNUNET_YES if this address is now used, GNUNET_NO
 570  * if address is not used any more
 571  */
 572 void
 573 GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
 574                            const struct GNUNET_HELLO_Address *address,
 575                            struct Session *session, int in_use);
 576
 577 /**
 578  * A session got destroyed, stop including it as a valid address.
 579  *
 580  * @param sh handle
 581  * @param address the address
 582  * @param session session handle that is no longer valid (if available)
 583  */
 584 void
 585 GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *sh,
 586                               const struct GNUNET_HELLO_Address *address,
 587                               struct Session *session);
 588
 589
 590 /* ******************************** Performance API ***************************** */
 591
 592 /**
 593  * ATS Handle to obtain and/or modify performance information.
 594  */
 595 struct GNUNET_ATS_PerformanceHandle;
 596
 597
 598 /**
 599  * Signature of a function that is called with QoS information about a peer.
 600  *
 601  * @param cls closure
 602  * @param address the address
 603  * @param bandwidth_out assigned outbound bandwidth for the connection
 604  * @param bandwidth_in assigned inbound bandwidth for the connection
 605  * @param ats performance data for the address (as far as known)
 606  * @param ats_count number of performance records in 'ats'
 607  */
 608 typedef void (*GNUNET_ATS_PeerInformationCallback) (void *cls,
 609                                                     const struct
 610                                                     GNUNET_HELLO_Address *
 611                                                     address,
 612                                                     struct
 613                                                     GNUNET_BANDWIDTH_Value32NBO
 614                                                     bandwidth_out,
 615                                                     struct
 616                                                     GNUNET_BANDWIDTH_Value32NBO
 617                                                     bandwidth_in,
 618                                                     const struct
 619                                                     GNUNET_ATS_Information *
 620                                                     ats, uint32_t ats_count);
 621
 622
 623 /**
 624  * Get handle to access performance API of the ATS subsystem.
 625  *
 626  * @param cfg configuration to use
 627  * @param infocb function to call on performance changes, can be NULL
 628  * @param infocb_cls closure for infocb
 629  * @return ats performance context
 630  */
 631 struct GNUNET_ATS_PerformanceHandle *
 632 GNUNET_ATS_performance_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
 633                              GNUNET_ATS_PeerInformationCallback infocb,
 634                              void *infocb_cls);
 635
 636
 637 /**
 638  * Client is done using the ATS performance subsystem, release resources.
 639  *
 640  * @param ph handle
 641  */
 642 void
 643 GNUNET_ATS_performance_done (struct GNUNET_ATS_PerformanceHandle *ph);
 644
 645
 646 /**
 647  * Function called with reservation result.
 648  *
 649  * @param cls closure
 650  * @param peer identifies the peer
 651  * @param amount set to the amount that was actually reserved or unreserved;
 652  *               either the full requested amount or zero (no partial reservations)
 653  * @param res_delay if the reservation could not be satisfied (amount was 0), how
 654  *        long should the client wait until re-trying?
 655  */
 656 typedef void (*GNUNET_ATS_ReservationCallback) (void *cls,
 657                                                 const struct GNUNET_PeerIdentity
 658                                                 * peer, int32_t amount,
 659                                                 struct GNUNET_TIME_Relative
 660                                                 res_delay);
 661
 662
 663
 664 /**
 665  * Context that can be used to cancel a peer information request.
 666  */
 667 struct GNUNET_ATS_ReservationContext;
 668
 669
 670 /**
 671  * Reserve inbound bandwidth from the given peer.  ATS will look at
 672  * the current amount of traffic we receive from the peer and ensure
 673  * that the peer could add 'amount' of data to its stream.
 674  *
 675  * @param ph performance handle
 676  * @param peer identifies the peer
 677  * @param amount reserve N bytes for receiving, negative
 678  *                amounts can be used to undo a (recent) reservation;
 679  * @param rcb function to call with the resulting reservation information
 680  * @param rcb_cls closure for info
 681  * @return NULL on error
 682  * @deprecated will be replaced soon
 683  */
 684 struct GNUNET_ATS_ReservationContext *
 685 GNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *ph,
 686                               const struct GNUNET_PeerIdentity *peer,
 687                               int32_t amount,
 688                               GNUNET_ATS_ReservationCallback rcb,
 689                               void *rcb_cls);
 690
 691
 692 /**
 693  * Cancel request for reserving bandwidth.
 694  *
 695  * @param rc context returned by the original GNUNET_ATS_reserve_bandwidth call
 696  */
 697 void
 698 GNUNET_ATS_reserve_bandwidth_cancel (struct GNUNET_ATS_ReservationContext *rc);
 699
 700
 701
 702 /**
 703  * Enum defining all known preference categories.
 704  */
 705 enum GNUNET_ATS_PreferenceKind
 706 {
 707
 708   /**
 709    * End of preference list.
 710    */
 711   GNUNET_ATS_PREFERENCE_END = 0,
 712
 713   /**
 714    * Change the peer's bandwidth value (value per byte of bandwidth in
 715    * the goal function) to the given amount.  The argument is followed
 716    * by a double value giving the desired value (can be negative).
 717    * Preference changes are forgotten if peers disconnect.
 718    */
 719   GNUNET_ATS_PREFERENCE_BANDWIDTH,
 720
 721   /**
 722    * Change the peer's latency value to the given amount.  The
 723    * argument is followed by a double value giving the desired value
 724    * (can be negative).  The absolute score in the goal function is
 725    * the inverse of the latency in ms (minimum: 1 ms) multiplied by
 726    * the latency preferences.
 727    */
 728   GNUNET_ATS_PREFERENCE_LATENCY
 729 };
 730
 731
 732 /**
 733  * Change preferences for the given peer. Preference changes are forgotten if peers
 734  * disconnect.
 735  *
 736  * @param ph performance handle
 737  * @param peer identifies the peer
 738  * @param ... 0-terminated specification of the desired changes
 739  */
 740 void
 741 GNUNET_ATS_change_preference (struct GNUNET_ATS_PerformanceHandle *ph,
 742                               const struct GNUNET_PeerIdentity *peer, ...);
 743
 744
 745
 746 #endif
 747 /* end of file gnunet-service-transport_ats.h */