- fixed string to address parsing
[oweals/gnunet.git] / 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  * Number of ATS quality properties
407  */
408 #define GNUNET_ATS_QualityPropertiesCount 2
409
410 /**
411  * ATS quality properties as array initializer
412  */
413 #define GNUNET_ATS_QualityProperties {GNUNET_ATS_QUALITY_NET_DELAY, GNUNET_ATS_QUALITY_NET_DISTANCE}
414
415 /**
416  * Number of ATS quality properties
417  */
418 #define GNUNET_ATS_NetworkTypeCount 5
419
420 /**
421  * ATS quality properties as array initializer
422  */
423 #define GNUNET_ATS_NetworkType {GNUNET_ATS_NET_UNSPECIFIED, GNUNET_ATS_NET_LOOPBACK, GNUNET_ATS_NET_LAN, GNUNET_ATS_NET_WAN, GNUNET_ATS_NET_WLAN}
424
425 GNUNET_NETWORK_STRUCT_BEGIN
426
427 /**
428  * struct used to communicate the transport's properties like cost and
429  * quality of service as well as high-level constraints on resource
430  * consumption.
431  *
432  *                             +---+
433  *  +-----------+ Constraints  |   |  Plugin properties +---------+
434  *  | Highlevel |------------> |ATS| <------------------|Transport|
435  *  | Component | ATS struct   |   |    ATS struct      | Plugin  |
436  *  +-----------+              |   |                    +---------+
437  *                             +---+
438  *
439  * This structure will be used by transport plugins to communicate
440  * costs to ATS or by higher level components to tell ATS their
441  * constraints.  Always a pair of (GNUNET_ATS_Property,
442  * uint32_t value).  Value is always uint32_t, so all units used to
443  * define costs have to be normalized to fit uint32_t.
444  */
445 struct GNUNET_ATS_Information
446 {
447   /**
448    * ATS property type, in network byte order.
449    */
450   uint32_t type GNUNET_PACKED;
451
452   /**
453    * ATS property value, in network byte order.
454    */
455   uint32_t value GNUNET_PACKED;
456 };
457 GNUNET_NETWORK_STRUCT_END
458
459
460 /* ******************************** Scheduling API ***************************** */
461
462 /**
463  * Handle to the ATS subsystem for bandwidth/transport scheduling information.
464  */
465 struct GNUNET_ATS_SchedulingHandle;
466
467
468 /**
469  * Opaque session handle, defined by plugins.  Contents not known to ATS.
470  */
471 struct Session;
472
473
474 /**
475  * Signature of a function called by ATS with the current bandwidth
476  * and address preferences as determined by ATS.
477  *
478  * @param cls closure
479  * @param address suggested address (including peer identity of the peer)
480  * @param session session to use
481  * @param bandwidth_out assigned outbound bandwidth for the connection
482  * @param bandwidth_in assigned inbound bandwidth for the connection
483  * @param ats performance data for the address (as far as known)
484  * @param ats_count number of performance records in 'ats'
485  */
486 typedef void (*GNUNET_ATS_AddressSuggestionCallback) (void *cls,
487                                                       const struct
488                                                       GNUNET_HELLO_Address *
489                                                       address,
490                                                       struct Session * session,
491                                                       struct
492                                                       GNUNET_BANDWIDTH_Value32NBO
493                                                       bandwidth_out,
494                                                       struct
495                                                       GNUNET_BANDWIDTH_Value32NBO
496                                                       bandwidth_in,
497                                                       const struct
498                                                       GNUNET_ATS_Information *
499                                                       ats, uint32_t ats_count);
500
501
502 /**
503  * Initialize the ATS subsystem.
504  *
505  * @param cfg configuration to use
506  * @param suggest_cb notification to call whenever the suggestation changed
507  * @param suggest_cb_cls closure for 'suggest_cb'
508  * @return ats context
509  */
510 struct GNUNET_ATS_SchedulingHandle *
511 GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
512                             GNUNET_ATS_AddressSuggestionCallback suggest_cb,
513                             void *suggest_cb_cls);
514
515
516 /**
517  * Client is done with ATS scheduling, release resources.
518  *
519  * @param sh handle to release
520  */
521 void
522 GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh);
523
524
525 /**
526  * We would like to establish a new connection with a peer.  ATS
527  * should suggest a good address to begin with.
528  *
529  * @param sh handle
530  * @param peer identity of the peer we need an address for
531  */
532 void
533 GNUNET_ATS_suggest_address (struct GNUNET_ATS_SchedulingHandle *sh,
534                             const struct GNUNET_PeerIdentity *peer);
535
536
537 /**
538  * We want to cancel ATS suggesting addresses for a peer.
539  *
540  * @param sh handle
541  * @param peer identity of the peer
542  */
543 void
544 GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SchedulingHandle *sh,
545                                    const struct GNUNET_PeerIdentity *peer);
546
547
548 /**
549  * Returns where the address is located: LAN or WAN or ...
550  * @param sh the GNUNET_ATS_SchedulingHandle handle
551  * @param addr address
552  * @param addrlen address length
553  * @return location as GNUNET_ATS_Information
554  */
555 const struct GNUNET_ATS_Information
556 GNUNET_ATS_address_get_type (struct GNUNET_ATS_SchedulingHandle *sh,
557                              const struct sockaddr * addr,
558                              socklen_t addrlen);
559
560
561 /**
562  * We have updated performance statistics for a given address.  Note
563  * that this function can be called for addresses that are currently
564  * in use as well as addresses that are valid but not actively in use.
565  * Furthermore, the peer may not even be connected to us right now (in
566  * which case the call may be ignored or the information may be stored
567  * for later use).  Update bandwidth assignments.
568  *
569  * @param sh handle
570  * @param address updated address
571  * @param session session handle (if available)
572  * @param ats performance data for the address
573  * @param ats_count number of performance records in 'ats'
574  */
575 void
576 GNUNET_ATS_address_update (struct GNUNET_ATS_SchedulingHandle *sh,
577                            const struct GNUNET_HELLO_Address *address,
578                            struct Session *session,
579                            const struct GNUNET_ATS_Information *ats,
580                            uint32_t ats_count);
581
582
583 /**
584  * An address is now in use or not used any more.
585  *
586  * @param sh handle
587  * @param address the address
588  * @param session session handle
589  * @param in_use GNUNET_YES if this address is now used, GNUNET_NO
590  * if address is not used any more
591  */
592 void
593 GNUNET_ATS_address_in_use (struct GNUNET_ATS_SchedulingHandle *sh,
594                            const struct GNUNET_HELLO_Address *address,
595                            struct Session *session, int in_use);
596
597 /**
598  * A session got destroyed, stop including it as a valid address.
599  *
600  * @param sh handle
601  * @param address the address
602  * @param session session handle that is no longer valid (if available)
603  */
604 void
605 GNUNET_ATS_address_destroyed (struct GNUNET_ATS_SchedulingHandle *sh,
606                               const struct GNUNET_HELLO_Address *address,
607                               struct Session *session);
608
609
610 /* ******************************** Performance API ***************************** */
611
612 /**
613  * ATS Handle to obtain and/or modify performance information.
614  */
615 struct GNUNET_ATS_PerformanceHandle;
616
617
618 /**
619  * Signature of a function that is called with QoS information about a peer.
620  *
621  * @param cls closure
622  * @param address the address
623  * @param bandwidth_out assigned outbound bandwidth for the connection
624  * @param bandwidth_in assigned inbound bandwidth for the connection
625  * @param ats performance data for the address (as far as known)
626  * @param ats_count number of performance records in 'ats'
627  */
628 typedef void (*GNUNET_ATS_PeerInformationCallback) (void *cls,
629                                                     const struct
630                                                     GNUNET_HELLO_Address *
631                                                     address,
632                                                     struct
633                                                     GNUNET_BANDWIDTH_Value32NBO
634                                                     bandwidth_out,
635                                                     struct
636                                                     GNUNET_BANDWIDTH_Value32NBO
637                                                     bandwidth_in,
638                                                     const struct
639                                                     GNUNET_ATS_Information *
640                                                     ats, uint32_t ats_count);
641
642
643 /**
644  * Get handle to access performance API of the ATS subsystem.
645  *
646  * @param cfg configuration to use
647  * @param infocb function to call on performance changes, can be NULL
648  * @param infocb_cls closure for infocb
649  * @return ats performance context
650  */
651 struct GNUNET_ATS_PerformanceHandle *
652 GNUNET_ATS_performance_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
653                              GNUNET_ATS_PeerInformationCallback infocb,
654                              void *infocb_cls);
655
656
657 /**
658  * Client is done using the ATS performance subsystem, release resources.
659  *
660  * @param ph handle
661  */
662 void
663 GNUNET_ATS_performance_done (struct GNUNET_ATS_PerformanceHandle *ph);
664
665
666 /**
667  * Function called with reservation result.
668  *
669  * @param cls closure
670  * @param peer identifies the peer
671  * @param amount set to the amount that was actually reserved or unreserved;
672  *               either the full requested amount or zero (no partial reservations)
673  * @param res_delay if the reservation could not be satisfied (amount was 0), how
674  *        long should the client wait until re-trying?
675  */
676 typedef void (*GNUNET_ATS_ReservationCallback) (void *cls,
677                                                 const struct GNUNET_PeerIdentity
678                                                 * peer, int32_t amount,
679                                                 struct GNUNET_TIME_Relative
680                                                 res_delay);
681
682
683
684 /**
685  * Context that can be used to cancel a peer information request.
686  */
687 struct GNUNET_ATS_ReservationContext;
688
689
690 /**
691  * Reserve inbound bandwidth from the given peer.  ATS will look at
692  * the current amount of traffic we receive from the peer and ensure
693  * that the peer could add 'amount' of data to its stream.
694  *
695  * @param ph performance handle
696  * @param peer identifies the peer
697  * @param amount reserve N bytes for receiving, negative
698  *                amounts can be used to undo a (recent) reservation;
699  * @param rcb function to call with the resulting reservation information
700  * @param rcb_cls closure for info
701  * @return NULL on error
702  * @deprecated will be replaced soon
703  */
704 struct GNUNET_ATS_ReservationContext *
705 GNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *ph,
706                               const struct GNUNET_PeerIdentity *peer,
707                               int32_t amount,
708                               GNUNET_ATS_ReservationCallback rcb,
709                               void *rcb_cls);
710
711
712 /**
713  * Cancel request for reserving bandwidth.
714  *
715  * @param rc context returned by the original GNUNET_ATS_reserve_bandwidth call
716  */
717 void
718 GNUNET_ATS_reserve_bandwidth_cancel (struct GNUNET_ATS_ReservationContext *rc);
719
720
721
722 /**
723  * Enum defining all known preference categories.
724  */
725 enum GNUNET_ATS_PreferenceKind
726 {
727
728   /**
729    * End of preference list.
730    */
731   GNUNET_ATS_PREFERENCE_END = 0,
732
733   /**
734    * Change the peer's bandwidth value (value per byte of bandwidth in
735    * the goal function) to the given amount.  The argument is followed
736    * by a double value giving the desired value (can be negative).
737    * Preference changes are forgotten if peers disconnect.
738    */
739   GNUNET_ATS_PREFERENCE_BANDWIDTH,
740
741   /**
742    * Change the peer's latency value to the given amount.  The
743    * argument is followed by a double value giving the desired value
744    * (can be negative).  The absolute score in the goal function is
745    * the inverse of the latency in ms (minimum: 1 ms) multiplied by
746    * the latency preferences.
747    */
748   GNUNET_ATS_PREFERENCE_LATENCY
749 };
750
751
752 /**
753  * Change preferences for the given peer. Preference changes are forgotten if peers
754  * disconnect.
755  *
756  * @param ph performance handle
757  * @param peer identifies the peer
758  * @param ... 0-terminated specification of the desired changes
759  */
760 void
761 GNUNET_ATS_change_preference (struct GNUNET_ATS_PerformanceHandle *ph,
762                               const struct GNUNET_PeerIdentity *peer, ...);
763
764
765
766 #endif
767 /* end of file gnunet-service-transport_ats.h */