ATS service

Bandwidth allocation. More...

Collaboration diagram for ATS service:

Data Structures
struct	GNUNET_ATS_Properties
	ATS performance characteristics for an address. More...
struct	GNUNET_ATS_PropertiesNBO
	ATS performance characteristics for an address in network byte order (for IPC). More...

Macros
#define	GNUNET_ATS_DefaultBandwidth   65536
	Default bandwidth assigned to a network : 64 KB/s. More...
#define	GNUNET_ATS_VALUE_UNDEFINED   UINT32_MAX
	Undefined value for an enum GNUNET_ATS_Property More...
#define	GNUNET_ATS_VALUE_UNDEFINED_STR   "undefined"
	String representation for GNUNET_ATS_VALUE_UNDEFINED. More...
#define	GNUNET_ATS_MaxBandwidth   UINT32_MAX
	Maximum bandwidth assigned to a network : 4095 MB/s. More...
#define	GNUNET_ATS_MaxBandwidthString   "unlimited"
	Textual equivalent for GNUNET_ATS_MaxBandwidth. More...
#define	GNUNET_ATS_PreferenceType
	ATS preference types as array initializer. More...
#define	GNUNET_ATS_PreferenceTypeString   { "BANDWIDTH", "LATENCY", "END" }
	ATS preference types as string array initializer. More...

Typedefs
typedef void(*	GNUNET_ATS_AddressSuggestionCallback) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
	Signature of a function called by ATS with the current bandwidth and address preferences as determined by ATS. More...
typedef void(*	GNUNET_ATS_AddressInformationCallback) (void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
	Signature of a function that is called with QoS information about an address. More...
typedef void(*	GNUNET_ATS_ReservationCallback) (void *cls, const struct GNUNET_PeerIdentity *peer, int32_t amount, struct GNUNET_TIME_Relative res_delay)
	Function called with reservation result. More...
typedef void(*	GNUNET_ATS_AllocationCallback) (void *cls, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
	Signature of a function called by ATS with the current bandwidth allocation to be used as determined by ATS. More...
typedef void(*	GNUNET_ATS_SuggestionCallback) (void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
	Signature of a function called by ATS suggesting transport to try connecting with a particular address. More...

Enumerations
enum	GNUNET_ATS_PreferenceKind { GNUNET_ATS_PREFERENCE_BANDWIDTH = 0 , GNUNET_ATS_PREFERENCE_LATENCY = 1 , GNUNET_ATS_PREFERENCE_END = 2 }
	Enum defining all known preference categories. More...

Functions
struct GNUNET_ATS_ApplicationHandle *	GNUNET_ATS_application_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the ATS application client handle. More...
void	GNUNET_ATS_application_done (struct GNUNET_ATS_ApplicationHandle *ch)
	Shutdown ATS application client. More...
struct GNUNET_ATS_ApplicationSuggestHandle *	GNUNET_ATS_application_suggest (struct GNUNET_ATS_ApplicationHandle *ch, const struct GNUNET_PeerIdentity *peer, enum GNUNET_MQ_PreferenceKind pk, struct GNUNET_BANDWIDTH_Value32NBO bw)
	An application would like to communicate with a peer. More...
void	GNUNET_ATS_application_suggest_cancel (struct GNUNET_ATS_ApplicationSuggestHandle *sh)
	We no longer care about communicating with a peer. More...
void	GNUNET_ATS_properties_hton (struct GNUNET_ATS_PropertiesNBO *nbo, const struct GNUNET_ATS_Properties *hbo)
	Convert ATS properties from host to network byte order. More...
void	GNUNET_ATS_properties_ntoh (struct GNUNET_ATS_Properties *hbo, const struct GNUNET_ATS_PropertiesNBO *nbo)
	Convert ATS properties from network to host byte order. More...
struct GNUNET_ATS_ConnectivityHandle *	GNUNET_ATS_connectivity_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the ATS connectivity suggestion client handle. More...
void	GNUNET_ATS_connectivity_done (struct GNUNET_ATS_ConnectivityHandle *ch)
	Shutdown ATS connectivity suggestion client. More...
struct GNUNET_ATS_ConnectivitySuggestHandle *	GNUNET_ATS_connectivity_suggest (struct GNUNET_ATS_ConnectivityHandle *ch, const struct GNUNET_PeerIdentity *peer, uint32_t strength)
	We would like to establish a new connection with a peer. More...
void	GNUNET_ATS_connectivity_suggest_cancel (struct GNUNET_ATS_ConnectivitySuggestHandle *sh)
	We no longer care about being connected to a peer. More...
struct GNUNET_ATS_SchedulingHandle *	GNUNET_ATS_scheduling_init (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressSuggestionCallback suggest_cb, void *suggest_cb_cls)
	Initialize the ATS scheduling subsystem. More...
void	GNUNET_ATS_scheduling_done (struct GNUNET_ATS_SchedulingHandle *sh)
	Client is done with ATS scheduling, release resources. More...
struct GNUNET_ATS_AddressRecord *	GNUNET_ATS_address_add (struct GNUNET_ATS_SchedulingHandle *sh, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_ATS_Properties *prop)
	We have a new address ATS should know. More...
void	GNUNET_ATS_address_add_session (struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
	An address was used to initiate a session. More...
int	GNUNET_ATS_address_del_session (struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
	A session was destroyed, disassociate it from the given address record. More...
void	GNUNET_ATS_address_update (struct GNUNET_ATS_AddressRecord *ar, const struct GNUNET_ATS_Properties *prop)
	We have updated performance statistics for a given address. More...
void	GNUNET_ATS_address_destroy (struct GNUNET_ATS_AddressRecord *ar)
	An address got destroyed, stop using it as a valid address. More...
struct GNUNET_ATS_PerformanceHandle *	GNUNET_ATS_performance_init (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressInformationCallback addr_info_cb, void *addr_info_cb_cls)
	Get handle to access performance API of the ATS subsystem. More...
struct GNUNET_ATS_AddressListHandle *	GNUNET_ATS_performance_list_addresses (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int all, GNUNET_ATS_AddressInformationCallback infocb, void *infocb_cls)
	Get information about addresses known to the ATS subsystem. More...
void	GNUNET_ATS_performance_list_addresses_cancel (struct GNUNET_ATS_AddressListHandle *alh)
	Cancel a pending address listing operation. More...
void	GNUNET_ATS_performance_done (struct GNUNET_ATS_PerformanceHandle *ph)
	Client is done using the ATS performance subsystem, release resources. More...
struct GNUNET_ATS_ReservationContext *	GNUNET_ATS_reserve_bandwidth (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, int32_t amount, GNUNET_ATS_ReservationCallback rcb, void *rcb_cls)
	Reserve inbound bandwidth from the given peer. More...
void	GNUNET_ATS_reserve_bandwidth_cancel (struct GNUNET_ATS_ReservationContext *rc)
	Cancel request for reserving bandwidth. More...
const char *	GNUNET_ATS_print_preference_type (enum GNUNET_ATS_PreferenceKind type)
	Convert an enum GNUNET_ATS_PreferenceType to a string. More...
void	GNUNET_ATS_performance_change_preference (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer,...)
	Change preferences for the given peer. More...
void	GNUNET_ATS_performance_give_feedback (struct GNUNET_ATS_PerformanceHandle *ph, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TIME_Relative scope,...)
	Application feedback on how good preference requirements are fulfilled for the preferences included in the given time scope [now - scope . More...
struct GNUNET_ATS_TransportHandle *	GNUNET_ATS_transport_init (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AllocationCallback alloc_cb, void *alloc_cb_cls, GNUNET_ATS_SuggestionCallback suggest_cb, void *suggest_cb_cls)
	Initialize the ATS transport subsystem. More...
void	GNUNET_ATS_transport_done (struct GNUNET_ATS_TransportHandle *ath)
	Client is done with ATS transport, release resources. More...
struct GNUNET_ATS_SessionRecord *	GNUNET_ATS_session_add (struct GNUNET_ATS_TransportHandle *ath, const struct GNUNET_PeerIdentity *pid, const char *address, struct GNUNET_ATS_Session *session, const struct GNUNET_ATS_Properties *prop)
	We have a new session ATS should know. More...
void	GNUNET_ATS_session_update (struct GNUNET_ATS_SessionRecord *ar, const struct GNUNET_ATS_Properties *prop)
	We have updated performance statistics for a given session. More...
void	GNUNET_ATS_session_del (struct GNUNET_ATS_SessionRecord *ar)
	A session was destroyed, ATS should now schedule and allocate under the assumption that this ar is no longer in use. More...

Detailed Description

Bandwidth allocation.

Bandwidth allocation for transport service.

Automatic Transport Selection and outbound bandwidth determination.

See also

Documentation

Macro Definition Documentation

GNUNET_ATS_DefaultBandwidth

#define GNUNET_ATS_DefaultBandwidth   65536

Default bandwidth assigned to a network : 64 KB/s.

Definition at line 49 of file gnunet_ats_service.h.

GNUNET_ATS_VALUE_UNDEFINED

#define GNUNET_ATS_VALUE_UNDEFINED   UINT32_MAX

Undefined value for an enum GNUNET_ATS_Property

Definition at line 54 of file gnunet_ats_service.h.

GNUNET_ATS_VALUE_UNDEFINED_STR

#define GNUNET_ATS_VALUE_UNDEFINED_STR   "undefined"

String representation for GNUNET_ATS_VALUE_UNDEFINED.

Definition at line 59 of file gnunet_ats_service.h.

GNUNET_ATS_MaxBandwidth

#define GNUNET_ATS_MaxBandwidth   UINT32_MAX

Maximum bandwidth assigned to a network : 4095 MB/s.

Definition at line 64 of file gnunet_ats_service.h.

GNUNET_ATS_MaxBandwidthString

#define GNUNET_ATS_MaxBandwidthString   "unlimited"

Textual equivalent for GNUNET_ATS_MaxBandwidth.

Definition at line 69 of file gnunet_ats_service.h.

GNUNET_ATS_PreferenceType

#define GNUNET_ATS_PreferenceType

Value:

                                    { GNUNET_ATS_PREFERENCE_BANDWIDTH, \
                                    GNUNET_ATS_PREFERENCE_LATENCY, \
                                    GNUNET_ATS_PREFERENCE_END }

ATS preference types as array initializer.

Definition at line 537 of file gnunet_ats_service.h.

GNUNET_ATS_PreferenceTypeString

#define GNUNET_ATS_PreferenceTypeString   { "BANDWIDTH", "LATENCY", "END" }

ATS preference types as string array initializer.

Definition at line 544 of file gnunet_ats_service.h.

Typedef Documentation

GNUNET_ATS_AddressSuggestionCallback

typedef void(* GNUNET_ATS_AddressSuggestionCallback) (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)

Signature of a function called by ATS with the current bandwidth and address preferences as determined by ATS.

If our connection to ATS dies and thus all suggestions become invalid, this function is called ONCE with all arguments (except cls) being NULL/0.

Parameters

cls	closure
peer	for which we suggest an address, NULL if ATS connection died
address	suggested address (including peer identity of the peer), may be NULL to signal disconnect from peer
session	session to use, NULL to establish a new outgoing session
bandwidth_out	assigned outbound bandwidth for the connection, 0 to signal disconnect
bandwidth_in	assigned inbound bandwidth for the connection, 0 to signal disconnect

Definition at line 268 of file gnunet_ats_service.h.

GNUNET_ATS_AddressInformationCallback

typedef void(* GNUNET_ATS_AddressInformationCallback) (void *cls, const struct GNUNET_HELLO_Address *address, int address_active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)

Signature of a function that is called with QoS information about an address.

Parameters

cls	closure
address	the address, NULL if ATS service was disconnected or when the iteration is completed in the case of GNUNET_ATS_performance_list_addresses()
address_active	GNUNET_YES if this address is actively used to maintain a connection to a peer; GNUNET_NO if the address is not actively used; GNUNET_SYSERR if this address is no longer available for ATS
bandwidth_out	assigned outbound bandwidth for the connection
bandwidth_in	assigned inbound bandwidth for the connection
prop	performance data for the address

Definition at line 406 of file gnunet_ats_service.h.

GNUNET_ATS_ReservationCallback

typedef void(* GNUNET_ATS_ReservationCallback) (void *cls, const struct GNUNET_PeerIdentity *peer, int32_t amount, struct GNUNET_TIME_Relative res_delay)

Function called with reservation result.

Parameters

cls	closure
peer	identifies the peer
amount	set to the amount that was actually reserved or unreserved; either the full requested amount or zero (no partial reservations)
res_delay	if the reservation could not be satisfied (amount was 0), how long should the client wait until re-trying?

Definition at line 490 of file gnunet_ats_service.h.

GNUNET_ATS_AllocationCallback

typedef void(* GNUNET_ATS_AllocationCallback) (void *cls, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)

Signature of a function called by ATS with the current bandwidth allocation to be used as determined by ATS.

Parameters

cls	closure
session	session this is about
bandwidth_out	assigned outbound bandwidth for the connection, 0 to signal disconnect
bandwidth_in	assigned inbound bandwidth for the connection, 0 to signal disconnect

Definition at line 136 of file gnunet_ats_transport_service.h.

GNUNET_ATS_SuggestionCallback

typedef void(* GNUNET_ATS_SuggestionCallback) (void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)

Signature of a function called by ATS suggesting transport to try connecting with a particular address.

Parameters

cls	closure
pid	target peer
address	the address to try

Definition at line 153 of file gnunet_ats_transport_service.h.

Enumeration Type Documentation

GNUNET_ATS_PreferenceKind

enum GNUNET_ATS_PreferenceKind

Enum defining all known preference categories.

Enumerator
GNUNET_ATS_PREFERENCE_BANDWIDTH	Change the peer's bandwidth value (value per byte of bandwidth in the goal function) to the given amount. The argument is followed by a double value giving the desired value (can be negative). Preference changes are forgotten if peers disconnect.
GNUNET_ATS_PREFERENCE_LATENCY	Change the peer's latency value to the given amount. The argument is followed by a double value giving the desired value (can be negative). The absolute score in the goal function is the inverse of the latency in microseconds (minimum: 1 microsecond) multiplied by the latency preferences.
GNUNET_ATS_PREFERENCE_END	End of preference list.

Definition at line 549 of file gnunet_ats_service.h.

{
  GNUNET_ATS_PREFERENCE_BANDWIDTH = 0,
 
  GNUNET_ATS_PREFERENCE_LATENCY = 1,
 
  GNUNET_ATS_PREFERENCE_END = 2
};

Function Documentation

GNUNET_ATS_application_init()

struct GNUNET_ATS_ApplicationHandle* GNUNET_ATS_application_init

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Initialize the ATS application client handle.

Parameters

cfg	configuration to use

Returns

ats application handle, NULL on error

GNUNET_ATS_application_done()

void GNUNET_ATS_application_done

(

struct GNUNET_ATS_ApplicationHandle *

ch

)

Shutdown ATS application client.

Parameters

ch	handle to destroy

GNUNET_ATS_application_suggest()

struct GNUNET_ATS_ApplicationSuggestHandle* GNUNET_ATS_application_suggest	(	struct GNUNET_ATS_ApplicationHandle *	ch,
		const struct GNUNET_PeerIdentity *	peer,
		enum GNUNET_MQ_PreferenceKind	pk,
		struct GNUNET_BANDWIDTH_Value32NBO	bw
	)

An application would like to communicate with a peer.

ATS should allocate bandwidth using a suitable address for requiremetns pk to transport.

Parameters

ch	handle
peer	identity of the peer we need an address for
pk	what kind of application will the application require (can be GNUNET_MQ_PREFERENCE_NONE, we will still try to connect)
bw	desired bandwidth, can be zero (we will still try to connect)

Returns

suggestion handle, NULL if request is already pending

GNUNET_ATS_application_suggest_cancel()

void GNUNET_ATS_application_suggest_cancel

(

struct GNUNET_ATS_ApplicationSuggestHandle *

sh

)

We no longer care about communicating with a peer.

Parameters

sh

handle

GNUNET_ATS_properties_hton()

void GNUNET_ATS_properties_hton	(	struct GNUNET_ATS_PropertiesNBO *	nbo,
		const struct GNUNET_ATS_Properties *	hbo
	)

Convert ATS properties from host to network byte order.

Parameters

nbo[out]	value written
hbo	value read
nbo[OUT]	value written
hbo	value read

Definition at line 36 of file ats_api_scanner.c.

{
  nbo->utilization_out = htonl (hbo->utilization_out);
  nbo->utilization_in = htonl (hbo->utilization_in);
  nbo->scope = htonl ((uint32_t) hbo->scope);
  nbo->distance = htonl (hbo->distance);
  nbo->delay = GNUNET_TIME_relative_hton (hbo->delay);
}

References GNUNET_ATS_PropertiesNBO::delay, GNUNET_ATS_Properties::delay, GNUNET_ATS_Properties::distance, GNUNET_ATS_PropertiesNBO::distance, GNUNET_TIME_relative_hton(), GNUNET_ATS_Properties::scope, GNUNET_ATS_PropertiesNBO::scope, GNUNET_ATS_Properties::utilization_in, GNUNET_ATS_PropertiesNBO::utilization_in, GNUNET_ATS_Properties::utilization_out, and GNUNET_ATS_PropertiesNBO::utilization_out.

Referenced by GNUNET_ATS_address_add(), GNUNET_ATS_address_update(), GNUNET_TRANSPORT_manipulation_set(), notify_client(), and transmit_req_addr().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_properties_ntoh()

void GNUNET_ATS_properties_ntoh	(	struct GNUNET_ATS_Properties *	hbo,
		const struct GNUNET_ATS_PropertiesNBO *	nbo
	)

Convert ATS properties from network to host byte order.

Parameters

hbo[out]	value written
nbo	value read
hbo[OUT]	value written
nbo	value read

Definition at line 54 of file ats_api_scanner.c.

{
  hbo->utilization_out = ntohl (nbo->utilization_out);
  hbo->utilization_in = ntohl (nbo->utilization_in);
  hbo->scope = ntohl ((uint32_t) nbo->scope);
  hbo->distance = ntohl (nbo->distance);
  hbo->delay = GNUNET_TIME_relative_ntoh (nbo->delay);
}

References GNUNET_ATS_PropertiesNBO::delay, GNUNET_ATS_Properties::delay, GNUNET_ATS_Properties::distance, GNUNET_ATS_PropertiesNBO::distance, GNUNET_TIME_relative_ntoh(), GNUNET_ATS_Properties::scope, GNUNET_ATS_PropertiesNBO::scope, GNUNET_ATS_Properties::utilization_in, GNUNET_ATS_PropertiesNBO::utilization_in, GNUNET_ATS_Properties::utilization_out, and GNUNET_ATS_PropertiesNBO::utilization_out.

Referenced by GAS_handle_address_add(), GAS_handle_address_update(), GST_manipulation_set_metric(), handle_address_list(), and handle_peer_information().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_connectivity_init()

struct GNUNET_ATS_ConnectivityHandle* GNUNET_ATS_connectivity_init

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Initialize the ATS connectivity suggestion client handle.

Parameters

cfg	configuration to use

Returns

ats connectivity handle, NULL on error

Definition at line 227 of file ats_api_connectivity.c.

{
  struct GNUNET_ATS_ConnectivityHandle *ch;
 
  ch = GNUNET_new (struct GNUNET_ATS_ConnectivityHandle);
  ch->cfg = cfg;
  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create (32,
                                                           GNUNET_YES);
  reconnect (ch);
  return ch;
}

References cfg, ch, GNUNET_CONTAINER_multipeermap_create(), GNUNET_new, GNUNET_YES, and reconnect().

Referenced by GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_start_peer(), libgnunet_plugin_dhtu_gnunet_init(), opstart_get_handle_ats_connectivity(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_connectivity_done()

void GNUNET_ATS_connectivity_done

(

struct GNUNET_ATS_ConnectivityHandle *

ch

)

Shutdown ATS connectivity suggestion client.

Parameters

ch	handle to destroy

Shutdown ATS connectivity suggestion client.

Parameters

ch	handle to release

Definition at line 267 of file ats_api_connectivity.c.

{
  if (NULL != ch->mq)
  {
    GNUNET_MQ_destroy (ch->mq);
    ch->mq = NULL;
  }
  if (NULL != ch->task)
  {
    GNUNET_SCHEDULER_cancel (ch->task);
    ch->task = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
                                         &free_sug_handle,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (ch->sug_requests);
  GNUNET_free (ch);
}

References ch, free_sug_handle(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), and GNUNET_CADET_Channel::mq.

Referenced by cleaning_task(), end(), GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), libgnunet_plugin_dhtu_gnunet_done(), oprelease_get_handle_ats_connectivity(), run(), shutdown_rest(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_connectivity_suggest()

struct GNUNET_ATS_ConnectivitySuggestHandle* GNUNET_ATS_connectivity_suggest	(	struct GNUNET_ATS_ConnectivityHandle *	ch,
		const struct GNUNET_PeerIdentity *	peer,
		uint32_t	strength
	)

We would like to establish a new connection with a peer.

ATS should suggest a good address to begin with.

Parameters

ch	handle
peer	identity of the peer we need an address for
strength	how urgent is the need for such a suggestion

Returns

suggestion handle, NULL if request is already pending

We would like to establish a new connection with a peer.

ATS will respond with a call to the continuation immediately containing an address or no address if none is available. ATS can suggest more addresses until we call GNUNET_ATS_connectivity_suggest_cancel().

Parameters

ch	handle
peer	identity of the peer we need an address for
strength	how urgent is the need for such a suggestion

Returns

suggest handle, NULL if a request is already pending

Definition at line 299 of file ats_api_connectivity.c.

{
  struct GNUNET_ATS_ConnectivitySuggestHandle *s;
 
  s = GNUNET_new (struct GNUNET_ATS_ConnectivitySuggestHandle);
  s->ch = ch;
  s->id = *peer;
  s->strength = strength;
  if (GNUNET_OK !=
      GNUNET_CONTAINER_multipeermap_put (ch->sug_requests,
                                         &s->id,
                                         s,
                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Not requesting ATS to suggest address for `%s', request already pending\n",
         GNUNET_i2s (peer));
    GNUNET_free (s);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Requesting ATS to suggest address for `%s'\n",
       GNUNET_i2s (peer));
  if (NULL == ch->mq)
    return s;
  (void) transmit_suggestion (ch,
                              &s->id,
                              s);
  return s;
}

References GNUNET_ATS_ConnectivitySuggestHandle::ch, ch, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_new, GNUNET_OK, GNUNET_ATS_ConnectivitySuggestHandle::id, LOG, GNUNET_CADET_Channel::mq, peer, GNUNET_ATS_ConnectivitySuggestHandle::strength, and transmit_suggestion().

Referenced by attempt_connect(), consider_peer_activate(), gnunet_drop(), gnunet_hold(), GNUNET_TRANSPORT_TESTING_connect_peers(), notify_disconnect(), occ_cache_get_handle_ats_occ_cb(), occ_cache_get_handle_ats_rocc_cb(), run(), and setup_neighbour().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_connectivity_suggest_cancel()

void GNUNET_ATS_connectivity_suggest_cancel

(

struct GNUNET_ATS_ConnectivitySuggestHandle *

sh

)

We no longer care about being connected to a peer.

Parameters

sh	handle to stop

Definition at line 334 of file ats_api_connectivity.c.

{
  struct GNUNET_ATS_ConnectivityHandle *ch = sh->ch;
  struct GNUNET_MQ_Envelope *ev;
  struct RequestAddressMessage *m;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Telling ATS we no longer care for an address for `%s'\n",
       GNUNET_i2s (&sh->id));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_remove (ch->sug_requests,
                                                       &sh->id,
                                                       sh));
  if (NULL == ch->mq)
  {
    GNUNET_free (sh);
    return;
  }
  ev = GNUNET_MQ_msg (m,
                      GNUNET_MESSAGE_TYPE_ATS_REQUEST_ADDRESS_CANCEL);
  m->strength = htonl (0);
  m->peer = sh->id;
  GNUNET_MQ_send (ch->mq, ev);
  GNUNET_free (sh);
}

Referenced by attempt_connect(), cleanup_occ_lp2c(), cleanup_rocc(), consider_peer_activate(), core_disconnect_cb(), destroy_peer(), end(), free_neighbour(), free_peer(), gnunet_drop(), gnunet_hold(), GNUNET_TRANSPORT_TESTING_connect_peers_cancel(), notify_connect(), and shutdown_task().

Here is the caller graph for this function:

GNUNET_ATS_scheduling_init()

struct GNUNET_ATS_SchedulingHandle* GNUNET_ATS_scheduling_init	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_ATS_AddressSuggestionCallback	suggest_cb,
		void *	suggest_cb_cls
	)

Initialize the ATS scheduling subsystem.

Parameters

cfg	configuration to use
suggest_cb	notification to call whenever the suggestation changed
suggest_cb_cls	closure for suggest_cb

Returns

ats context

Definition at line 561 of file ats_api_scheduling.c.

{
  struct GNUNET_ATS_SchedulingHandle *sh;
 
  sh = GNUNET_new (struct GNUNET_ATS_SchedulingHandle);
  sh->cfg = cfg;
  sh->suggest_cb = suggest_cb;
  sh->suggest_cb_cls = suggest_cb_cls;
  GNUNET_array_grow (sh->session_array,
                     sh->session_array_size,
                     4);
  reconnect (sh);
  return sh;
}

References cfg, GNUNET_array_grow, GNUNET_new, reconnect(), sh, GNUNET_ATS_SchedulingHandle::suggest_cb, and GNUNET_ATS_SchedulingHandle::suggest_cb_cls.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_scheduling_done()

void GNUNET_ATS_scheduling_done

(

struct GNUNET_ATS_SchedulingHandle *

sh

)

Client is done with ATS scheduling, release resources.

Parameters

sh	handle to release

Definition at line 585 of file ats_api_scheduling.c.

{
  struct GNUNET_ATS_AddressRecord *ar;
  unsigned int i;
 
  if (NULL != sh->mq)
  {
    GNUNET_MQ_destroy (sh->mq);
    sh->mq = NULL;
  }
  if (NULL != sh->task)
  {
    GNUNET_SCHEDULER_cancel (sh->task);
    sh->task = NULL;
  }
  for (i = 0; i < sh->session_array_size; i++)
  {
    if (NULL != (ar = sh->session_array[i]))
    {
      GNUNET_HELLO_address_free (ar->address);
      GNUNET_free (ar);
      sh->session_array[i] = NULL;
    }
  }
  GNUNET_array_grow (sh->session_array,
                     sh->session_array_size,
                     0);
  GNUNET_free (sh);
}

References GNUNET_ATS_AddressRecord::address, GNUNET_array_grow, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), and sh.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_address_add()

struct GNUNET_ATS_AddressRecord* GNUNET_ATS_address_add	(	struct GNUNET_ATS_SchedulingHandle *	sh,
		const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		const struct GNUNET_ATS_Properties *	prop
	)

We have a new address ATS should know.

Addresses have to be added with this function before they can be: updated, set in use and destroyed

Parameters

sh	handle
address	the address
session	session handle (if available, e.g for incoming connections)
prop	performance data for the address

Returns

handle to the address representation inside ATS, NULL on error (i.e. ATS knows this exact address already, or address is invalid)

Addresses have to be added with this function before they can be: updated, set in use and destroyed.

Parameters

sh	handle
address	the address
session	session handle, can be NULL
prop	performance data for the address

Returns

handle to the address representation inside ATS, NULL on error (i.e. ATS knows this exact address already)

Definition at line 629 of file ats_api_scheduling.c.

{
  struct GNUNET_ATS_AddressRecord *ar;
  size_t namelen;
  size_t msize;
  uint32_t s;
 
  if (NULL == address)
  {
    /* we need a valid address */
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
  namelen = strlen (address->transport_name) + 1;
  msize = address->address_length + namelen;
  if ((msize + sizeof(struct AddressUpdateMessage) >=
       GNUNET_MAX_MESSAGE_SIZE) ||
      (address->address_length >= GNUNET_MAX_MESSAGE_SIZE) ||
      (namelen >= GNUNET_MAX_MESSAGE_SIZE))
  {
    /* address too large for us, this should not happen */
    GNUNET_break (0);
    return NULL;
  }
 
  if (NOT_FOUND !=
      find_session_id (sh,
                       session,
                       address))
  {
    /* Already existing, nothing todo, but this should not happen */
    GNUNET_break (0);
    return NULL;
  }
  s = find_empty_session_slot (sh);
  ar = GNUNET_new (struct GNUNET_ATS_AddressRecord);
  ar->sh = sh;
  ar->slot = s;
  ar->session = session;
  ar->address = GNUNET_HELLO_address_copy (address);
  GNUNET_ATS_properties_hton (&ar->properties,
                              prop);
  sh->session_array[s] = ar;
  send_add_address_message (sh, ar);
  return ar;
}

References GNUNET_ATS_AddressRecord::address, address, find_empty_session_slot(), find_session_id(), GNUNET_ATS_properties_hton(), GNUNET_break, GNUNET_HELLO_address_copy(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_new, GNUNET_NT_UNSPECIFIED, NOT_FOUND, GNUNET_ATS_AddressRecord::properties, GNUNET_ATS_Properties::scope, send_add_address_message(), GNUNET_ATS_AddressRecord::session, GNUNET_ATS_AddressRecord::sh, sh, and GNUNET_ATS_AddressRecord::slot.

Referenced by GST_ats_add_address(), GST_ats_add_inbound_address(), and unblock_address().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_address_add_session()

void GNUNET_ATS_address_add_session	(	struct GNUNET_ATS_AddressRecord *	ar,
		struct GNUNET_ATS_Session *	session
	)

An address was used to initiate a session.

Parameters

ar	address record to update information for
session	session handle

Definition at line 688 of file ats_api_scheduling.c.

{
  GNUNET_break (NULL == ar->session);
  ar->session = session;
}

References GNUNET_break, and GNUNET_ATS_AddressRecord::session.

Referenced by GST_ats_new_session().

Here is the caller graph for this function:

GNUNET_ATS_address_del_session()

int GNUNET_ATS_address_del_session	(	struct GNUNET_ATS_AddressRecord *	ar,
		struct GNUNET_ATS_Session *	session
	)

A session was destroyed, disassociate it from the given address record.

If this was an incoming address, destroys the address as well.

Parameters

ar	address record to update information for
session	session handle

Returns

GNUNET_YES if the ar was destroyed because it was an incoming address, GNUNET_NO if the ar was kept because we can use it still to establish a new session

Definition at line 697 of file ats_api_scheduling.c.

{
  GNUNET_assert (session == ar->session);
  ar->session = NULL;
  if (GNUNET_HELLO_address_check_option (ar->address,
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND))
  {
    GNUNET_ATS_address_destroy (ar);
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References GNUNET_ATS_AddressRecord::address, GNUNET_assert, GNUNET_ATS_address_destroy(), GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_NO, GNUNET_YES, and GNUNET_ATS_AddressRecord::session.

Referenced by GST_ats_block_address(), and GST_ats_del_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_address_update()

void GNUNET_ATS_address_update	(	struct GNUNET_ATS_AddressRecord *	ar,
		const struct GNUNET_ATS_Properties *	prop
	)

We have updated performance statistics for a given address.

Note that this function can be called for addresses that are currently in use as well as addresses that are valid but not actively in use. Furthermore, the peer may not even be connected to us right now (session value of NULL used to signal disconnect, or somehow we otherwise got updated on ats information). Based on the information provided, ATS may update bandwidth assignments and suggest to switch addresses.

Parameters

ar	address record to update information for
prop	performance data for the address

Note that this function can be called for addresses that are currently in use as well as addresses that are valid but not actively in use. Furthermore, the peer may not even be connected to us right now (in which case the call may be ignored or the information may be stored for later use). Update bandwidth assignments.

Parameters

ar	address record to update information for
prop	performance data for the address

Definition at line 724 of file ats_api_scheduling.c.

{
  struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
  struct GNUNET_MQ_Envelope *ev;
  struct AddressUpdateMessage *m;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updating address for peer `%s', plugin `%s', session %p slot %u\n",
       GNUNET_i2s (&ar->address->peer),
       ar->address->transport_name,
       ar->session,
       ar->slot);
  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
  GNUNET_ATS_properties_hton (&ar->properties,
                              prop);
  if (NULL == sh->mq)
    return; /* disconnected, skip for now */
  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE);
  m->session_id = htonl (ar->slot);
  m->peer = ar->address->peer;
  m->properties = ar->properties;
  GNUNET_MQ_send (sh->mq,
                  ev);
}

References GNUNET_ATS_AddressRecord::address, GNUNET_ATS_properties_hton(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_ATS_ADDRESS_UPDATE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NT_UNSPECIFIED, LOG, m, GNUNET_HELLO_Address::peer, GNUNET_ATS_AddressRecord::properties, GNUNET_ATS_Properties::scope, GNUNET_ATS_AddressRecord::session, GNUNET_ATS_AddressRecord::sh, sh, GNUNET_ATS_AddressRecord::slot, and GNUNET_HELLO_Address::transport_name.

Referenced by GST_ats_update_delay(), GST_ats_update_distance(), and GST_ats_update_utilization().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_address_destroy()

void GNUNET_ATS_address_destroy

(

struct GNUNET_ATS_AddressRecord *

ar

)

An address got destroyed, stop using it as a valid address.

Parameters

ar	address record to destroy, its validation has expired and ATS may no longer use it
ar	address to destroy

Definition at line 757 of file ats_api_scheduling.c.

{
  struct GNUNET_ATS_SchedulingHandle *sh = ar->sh;
  struct GNUNET_MQ_Envelope *ev;
  struct AddressDestroyedMessage *m;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Deleting address for peer `%s', plugin `%s', slot %u session %p\n",
       GNUNET_i2s (&ar->address->peer),
       ar->address->transport_name,
       ar->slot,
       ar->session);
  GNUNET_break (NULL == ar->session);
  ar->session = NULL;
  ar->in_destroy = GNUNET_YES;
  if (NULL == sh->mq)
    return;
  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED);
  m->session_id = htonl (ar->slot);
  m->peer = ar->address->peer;
  GNUNET_MQ_send (sh->mq, ev);
}

References GNUNET_ATS_AddressRecord::address, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MESSAGE_TYPE_ATS_ADDRESS_DESTROYED, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, GNUNET_ATS_AddressRecord::in_destroy, LOG, m, GNUNET_HELLO_Address::peer, GNUNET_ATS_AddressRecord::session, GNUNET_ATS_AddressRecord::sh, sh, GNUNET_ATS_AddressRecord::slot, and GNUNET_HELLO_Address::transport_name.

Referenced by destroy_ai(), GNUNET_ATS_address_del_session(), GST_ats_block_address(), and GST_ats_del_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_performance_init()

struct GNUNET_ATS_PerformanceHandle* GNUNET_ATS_performance_init	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_ATS_AddressInformationCallback	addr_info_cb,
		void *	addr_info_cb_cls
	)

Get handle to access performance API of the ATS subsystem.

Parameters

cfg	configuration to use
addr_info_cb	callback called when performance characteristics for an address change
addr_info_cb_cls	closure for addr_info_cb

Returns

ats performance context

Definition at line 613 of file ats_api_performance.c.

{
  struct GNUNET_ATS_PerformanceHandle *ph;
 
  ph = GNUNET_new (struct GNUNET_ATS_PerformanceHandle);
  ph->cfg = cfg;
  ph->addr_info_cb = addr_info_cb;
  ph->addr_info_cb_cls = addr_info_cb_cls;
  reconnect (ph);
  if (NULL == ph->mq)
  {
    GNUNET_free (ph);
    return NULL;
  }
  return ph;
}

References GNUNET_ATS_PerformanceHandle::addr_info_cb, addr_info_cb(), GNUNET_ATS_PerformanceHandle::addr_info_cb_cls, cfg, GNUNET_ATS_PerformanceHandle::cfg, GNUNET_free, GNUNET_new, GNUNET_ATS_PerformanceHandle::mq, ph, and reconnect().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_performance_list_addresses()

struct GNUNET_ATS_AddressListHandle* GNUNET_ATS_performance_list_addresses	(	struct GNUNET_ATS_PerformanceHandle *	ph,
		const struct GNUNET_PeerIdentity *	peer,
		int	all,
		GNUNET_ATS_AddressInformationCallback	infocb,
		void *	infocb_cls
	)

Get information about addresses known to the ATS subsystem.

Parameters

ph	the performance handle to use
peer	peer idm can be NULL for all peers
all	GNUNET_YES to get information about all addresses or GNUNET_NO to get only address currently used
infocb	callback to call with the addresses, will callback with address == NULL when done
infocb_cls	closure for infocb

Returns

handle to abort the operation

Definition at line 715 of file ats_api_performance.c.

{
  struct GNUNET_ATS_AddressListHandle *alh;
  struct GNUNET_MQ_Envelope *env;
  struct AddressListRequestMessage *m;
 
  if (NULL == ph->mq)
    return NULL;
  if (NULL == infocb)
  {
    GNUNET_break (0);
    return NULL;
  }
  alh = GNUNET_new (struct GNUNET_ATS_AddressListHandle);
  alh->id = ph->id++;
  alh->cb = infocb;
  alh->cb_cls = infocb_cls;
  alh->ph = ph;
  alh->all_addresses = all;
  if (NULL == peer)
  {
    alh->all_peers = GNUNET_YES;
  }
  else
  {
    alh->all_peers = GNUNET_NO;
    alh->peer = *peer;
  }
  GNUNET_CONTAINER_DLL_insert (ph->addresslist_head,
                               ph->addresslist_tail,
                               alh);
  env = GNUNET_MQ_msg (m,
                       GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST);
  m->all = htonl (all);
  m->id = htonl (alh->id);
  if (NULL != peer)
    m->peer = *peer;
  GNUNET_MQ_send (ph->mq,
                  env);
  return alh;
}

References GNUNET_ATS_PerformanceHandle::addresslist_head, GNUNET_ATS_PerformanceHandle::addresslist_tail, alh, AddressListRequestMessage::all, GNUNET_ATS_AddressListHandle::all_addresses, GNUNET_ATS_AddressListHandle::all_peers, GNUNET_ATS_AddressListHandle::cb, GNUNET_ATS_AddressListHandle::cb_cls, env, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_REQUEST, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_YES, GNUNET_ATS_AddressListHandle::id, GNUNET_ATS_PerformanceHandle::id, m, GNUNET_ATS_PerformanceHandle::mq, GNUNET_ATS_AddressListHandle::peer, peer, ph, and GNUNET_ATS_AddressListHandle::ph.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_performance_list_addresses_cancel()

void GNUNET_ATS_performance_list_addresses_cancel

(

struct GNUNET_ATS_AddressListHandle *

alh

)

Cancel a pending address listing operation.

Parameters

alh	the struct GNUNET_ATS_AddressListHandle handle to cancel

Definition at line 764 of file ats_api_performance.c.

{
  struct GNUNET_ATS_PerformanceHandle *ph = alh->ph;
 
  GNUNET_CONTAINER_DLL_remove (ph->addresslist_head,
                               ph->addresslist_tail,
                               alh);
  GNUNET_free (alh);
}

References GNUNET_ATS_PerformanceHandle::addresslist_head, GNUNET_ATS_PerformanceHandle::addresslist_tail, alh, GNUNET_CONTAINER_DLL_remove, GNUNET_free, ph, and GNUNET_ATS_AddressListHandle::ph.

Referenced by end().

Here is the caller graph for this function:

GNUNET_ATS_performance_done()

void GNUNET_ATS_performance_done

(

struct GNUNET_ATS_PerformanceHandle *

ph

)

Client is done using the ATS performance subsystem, release resources.

Parameters

ph

handle

Definition at line 639 of file ats_api_performance.c.

{
  struct GNUNET_ATS_ReservationContext *rc;
  struct GNUNET_ATS_AddressListHandle *alh;
 
  while (NULL != (alh = ph->addresslist_head))
  {
    GNUNET_CONTAINER_DLL_remove (ph->addresslist_head,
                                 ph->addresslist_tail,
                                 alh);
    GNUNET_free (alh);
  }
  while (NULL != (rc = ph->reservation_head))
  {
    GNUNET_CONTAINER_DLL_remove (ph->reservation_head,
                                 ph->reservation_tail,
                                 rc);
    GNUNET_break (NULL == rc->rcb);
    GNUNET_free (rc);
  }
  if (NULL != ph->task)
  {
    GNUNET_SCHEDULER_cancel (ph->task);
    ph->task = NULL;
  }
  if (NULL != ph->mq)
  {
    GNUNET_MQ_destroy (ph->mq);
    ph->mq = NULL;
  }
  GNUNET_free (ph);
}

References GNUNET_ATS_PerformanceHandle::addresslist_head, GNUNET_ATS_PerformanceHandle::addresslist_tail, alh, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_ATS_PerformanceHandle::mq, ph, GNUNET_ATS_ReservationContext::rcb, GNUNET_ATS_PerformanceHandle::reservation_head, GNUNET_ATS_PerformanceHandle::reservation_tail, and GNUNET_ATS_PerformanceHandle::task.

Referenced by do_shutdown(), end(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_reserve_bandwidth()

struct GNUNET_ATS_ReservationContext* GNUNET_ATS_reserve_bandwidth	(	struct GNUNET_ATS_PerformanceHandle *	ph,
		const struct GNUNET_PeerIdentity *	peer,
		int32_t	amount,
		GNUNET_ATS_ReservationCallback	rcb,
		void *	rcb_cls
	)

Reserve inbound bandwidth from the given peer.

ATS will look at the current amount of traffic we receive from the peer and ensure that the peer could add 'amount' of data to its stream.

Parameters

ph	performance handle
peer	identifies the peer
amount	reserve N bytes for receiving, negative amounts can be used to undo a (recent) reservation;
rcb	function to call with the resulting reservation information
rcb_cls	closure for rcb

Returns

NULL on error

Deprecated:

will be replaced soon

Definition at line 674 of file ats_api_performance.c.

{
  struct GNUNET_ATS_ReservationContext *rc;
  struct GNUNET_MQ_Envelope *env;
  struct ReservationRequestMessage *m;
 
  if (NULL == ph->mq)
    return NULL;
  rc = GNUNET_new (struct GNUNET_ATS_ReservationContext);
  rc->size = amount;
  rc->peer = *peer;
  rc->rcb = rcb;
  rc->rcb_cls = rcb_cls;
  if ((NULL != rcb) &&
      (amount > 0))
    rc->undo = GNUNET_YES;
  GNUNET_CONTAINER_DLL_insert_tail (ph->reservation_head,
                                    ph->reservation_tail,
                                    rc);
  env = GNUNET_MQ_msg (m,
                       GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST);
  m->amount = htonl (amount);
  m->peer = *peer;
  GNUNET_MQ_send (ph->mq,
                  env);
  return rc;
}

References ReservationRequestMessage::amount, env, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_MESSAGE_TYPE_ATS_RESERVATION_REQUEST, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_YES, m, GNUNET_ATS_PerformanceHandle::mq, GNUNET_ATS_ReservationContext::peer, peer, ph, GNUNET_ATS_ReservationContext::rcb, GNUNET_ATS_ReservationContext::rcb_cls, GNUNET_ATS_PerformanceHandle::reservation_head, GNUNET_ATS_PerformanceHandle::reservation_tail, GNUNET_ATS_ReservationContext::size, and GNUNET_ATS_ReservationContext::undo.

Referenced by GSF_peer_connect_handler(), handle_reservation_result(), retry_reservation(), and schedule_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_reserve_bandwidth_cancel()

void GNUNET_ATS_reserve_bandwidth_cancel

(

struct GNUNET_ATS_ReservationContext *

rc

)

Cancel request for reserving bandwidth.

Parameters

rc	context returned by the original GNUNET_ATS_reserve_bandwidth() call

Definition at line 708 of file ats_api_performance.c.

{
  rc->rcb = NULL;
}

References GNUNET_ATS_ReservationContext::rcb.

Referenced by GSF_peer_disconnect_handler().

Here is the caller graph for this function:

GNUNET_ATS_print_preference_type()

const char* GNUNET_ATS_print_preference_type

(

enum GNUNET_ATS_PreferenceKind

type

)

Convert an enum GNUNET_ATS_PreferenceType to a string.

Parameters

type	the preference type

Returns

a string or NULL if invalid

Definition at line 777 of file ats_api_performance.c.

{
  const char *prefs[] = GNUNET_ATS_PreferenceTypeString;
 
  if (type < GNUNET_ATS_PREFERENCE_END)
    return prefs[type];
  return NULL;
}

References GNUNET_ATS_PREFERENCE_END, GNUNET_ATS_PreferenceTypeString, and type.

Referenced by GNUNET_ATS_solver_generate_preferences_start(), GNUNET_ATS_solver_generate_preferences_stop(), GNUNET_ATS_solver_logging_eval(), GNUNET_ATS_solver_logging_now(), load_op_start_set_preference(), load_op_stop_set_preference(), recalculate_relative_preferences(), set_feedback_task(), set_pref_task(), update_preference(), update_rel_sum(), and update_relative_values_for_peer().

Here is the caller graph for this function:

GNUNET_ATS_performance_change_preference()

void GNUNET_ATS_performance_change_preference	(	struct GNUNET_ATS_PerformanceHandle *	ph,
		const struct GNUNET_PeerIdentity *	peer,
			...
	)

Change preferences for the given peer.

Preference changes are forgotten if peers disconnect.

Parameters

ph	performance handle
peer	identifies the peer
...	GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes

Definition at line 788 of file ats_api_performance.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct ChangePreferenceMessage *m;
  uint32_t count;
  struct PreferenceInformation *pi;
  va_list ap;
  enum GNUNET_ATS_PreferenceKind kind;
 
  if (NULL == ph->mq)
    return;
  count = 0;
  va_start (ap, peer);
  while (GNUNET_ATS_PREFERENCE_END !=
         (kind = GNUNET_VA_ARG_ENUM (ap, GNUNET_ATS_PreferenceKind)))
  {
    switch (kind)
    {
    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
      count++;
      (void) va_arg (ap, double);
      break;
 
    case GNUNET_ATS_PREFERENCE_LATENCY:
      count++;
      (void) va_arg (ap, double);
      break;
 
    default:
      GNUNET_assert (0);
    }
  }
  va_end (ap);
  env = GNUNET_MQ_msg_extra (m,
                             count * sizeof(struct PreferenceInformation),
                             GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE);
  m->num_preferences = htonl (count);
  m->peer = *peer;
  pi = (struct PreferenceInformation *) &m[1];
  count = 0;
  va_start (ap, peer);
  while (GNUNET_ATS_PREFERENCE_END != (kind =
                                         GNUNET_VA_ARG_ENUM (ap,
                                                             GNUNET_ATS_PreferenceKind)))
  {
    pi[count].preference_kind = htonl (kind);
    switch (kind)
    {
    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
      pi[count].preference_value = (float) va_arg (ap, double);
 
      count++;
      break;
 
    case GNUNET_ATS_PREFERENCE_LATENCY:
      pi[count].preference_value = (float) va_arg (ap, double);
 
      count++;
      break;
 
    default:
      GNUNET_assert (0);
    }
  }
  va_end (ap);
  GNUNET_MQ_send (ph->mq,
                  env);
}

References env, GNUNET_assert, GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_ATS_PREFERENCE_END, GNUNET_ATS_PREFERENCE_LATENCY, GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_CHANGE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_VA_ARG_ENUM, m, GNUNET_ATS_PerformanceHandle::mq, peer, ph, and pi.

Referenced by run(), and schedule_transmission().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_ATS_performance_give_feedback()

void GNUNET_ATS_performance_give_feedback	(	struct GNUNET_ATS_PerformanceHandle *	ph,
		const struct GNUNET_PeerIdentity *	peer,
		const struct GNUNET_TIME_Relative	scope,
			...
	)

Application feedback on how good preference requirements are fulfilled for the preferences included in the given time scope [now - scope .

. now]

An application notifies ATS if (and only if) it has feedback information for specific properties. This values are valid until the feedback scores are updated by the application.

If the application has no feedback for this preference kind the application will not explicitly call for this property and will not include it in this function call.

Parameters

ph	performance handle
scope	the time interval this valid for: [now - scope .. now]
peer	identifies the peer
...	GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes

Application feedback on how good preference requirements are fulfilled for the preferences included in the given time scope [now - scope .

Parameters

ph	performance handle
scope	the time interval this valid for: [now - scope .. now]
peer	identifies the peer
...	GNUNET_ATS_PREFERENCE_END-terminated specification of the desired changes

Definition at line 872 of file ats_api_performance.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct FeedbackPreferenceMessage *m;
  uint32_t count;
  struct PreferenceInformation *pi;
  va_list ap;
  enum GNUNET_ATS_PreferenceKind kind;
 
  if (NULL == ph->mq)
    return;
  count = 0;
  va_start (ap, scope);
  while (GNUNET_ATS_PREFERENCE_END !=
         (kind = GNUNET_VA_ARG_ENUM (ap, GNUNET_ATS_PreferenceKind)))
  {
    switch (kind)
    {
    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
      count++;
      (void) va_arg (ap, double);
      break;
 
    case GNUNET_ATS_PREFERENCE_LATENCY:
      count++;
      (void) va_arg (ap, double);
      break;
 
    default:
      GNUNET_assert (0);
    }
  }
  va_end (ap);
  env = GNUNET_MQ_msg_extra (m,
                             count * sizeof(struct PreferenceInformation),
                             GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK);
  m->scope = GNUNET_TIME_relative_hton (scope);
  m->num_feedback = htonl (count);
  m->peer = *peer;
  pi = (struct PreferenceInformation *) &m[1];
  count = 0;
  va_start (ap, scope);
  while (GNUNET_ATS_PREFERENCE_END != (kind =
                                         GNUNET_VA_ARG_ENUM (ap,
                                                             GNUNET_ATS_PreferenceKind)))
  {
    pi[count].preference_kind = htonl (kind);
    switch (kind)
    {
    case GNUNET_ATS_PREFERENCE_BANDWIDTH:
      pi[count].preference_value = (float) va_arg (ap, double);
 
      count++;
      break;
 
    case GNUNET_ATS_PREFERENCE_LATENCY:
      pi[count].preference_value = (float) va_arg (ap, double);
 
      count++;
      break;
 
    default:
      GNUNET_assert (0);
    }
  }
  va_end (ap);
  GNUNET_MQ_send (ph->mq,
                  env);
}

References env, GNUNET_assert, GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_ATS_PREFERENCE_END, GNUNET_ATS_PREFERENCE_LATENCY, GNUNET_MESSAGE_TYPE_ATS_PREFERENCE_FEEDBACK, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_relative_hton(), GNUNET_VA_ARG_ENUM, m, GNUNET_ATS_PerformanceHandle::mq, peer, ph, pi, and scope.

Here is the call graph for this function:

GNUNET_ATS_transport_init()

struct GNUNET_ATS_TransportHandle* GNUNET_ATS_transport_init	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_ATS_AllocationCallback	alloc_cb,
		void *	alloc_cb_cls,
		GNUNET_ATS_SuggestionCallback	suggest_cb,
		void *	suggest_cb_cls
	)

Initialize the ATS transport subsystem.

Parameters

cfg	configuration to use
alloc_cb	notification to call whenever the allocation changed
alloc_cb_cls	closure for alloc_cb
suggest_cb	notification to call whenever the suggestation is made
suggest_cb_cls	closure for suggest_cb

Returns

ats context

GNUNET_ATS_transport_done()

void GNUNET_ATS_transport_done

(

struct GNUNET_ATS_TransportHandle *

ath

)

Client is done with ATS transport, release resources.

Parameters

ath	handle to release

GNUNET_ATS_session_add()

struct GNUNET_ATS_SessionRecord* GNUNET_ATS_session_add	(	struct GNUNET_ATS_TransportHandle *	ath,
		const struct GNUNET_PeerIdentity *	pid,
		const char *	address,
		struct GNUNET_ATS_Session *	session,
		const struct GNUNET_ATS_Properties *	prop
	)

We have a new session ATS should know.

Sessiones have to be added with this function before they can be: updated, set in use and destroyed

Parameters

ath	handle
pid	peer we connected to
address	the address (human readable version),
session	transport-internal handle for the session/queue, NULL if the session is inbound-only
prop	performance data for the session

Returns

handle to the session representation inside ATS, NULL on error (i.e. ATS knows this exact session already, or session is invalid)

GNUNET_ATS_session_update()

void GNUNET_ATS_session_update	(	struct GNUNET_ATS_SessionRecord *	ar,
		const struct GNUNET_ATS_Properties *	prop
	)

We have updated performance statistics for a given session.

Based on the information provided, ATS may update bandwidth assignments.

Parameters

ar	session record to update information for
prop	performance data for the session

GNUNET_ATS_session_del()

void GNUNET_ATS_session_del

(

struct GNUNET_ATS_SessionRecord *

ar

)

A session was destroyed, ATS should now schedule and allocate under the assumption that this ar is no longer in use.

Parameters

ar	session record to drop