gnunet-service-transport_ats.c File Reference

interfacing between transport and ATS service More...

#include "platform.h"
#include "gnunet-service-transport.h"
#include "gnunet-service-transport_ats.h"
#include "gnunet-service-transport_manipulation.h"
#include "gnunet-service-transport_plugins.h"
#include "gnunet_ats_service.h"

Include dependency graph for gnunet-service-transport_ats.c:

Go to the source code of this file.

Data Structures
struct	AddressInfo
	Information we track for each address known to ATS. More...
struct	FindClosure
	Closure for find_ai_cb() and find_ai_no_session_cb(). More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "transport-ats", __VA_ARGS__)
	Log convenience function. More...

Functions
static void	publish_p2a_stat_update ()
	Provide an update on the p2a map size to statistics. More...
static int	find_ai_cb (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Find matching address info. More...
static struct AddressInfo *	find_ai (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Find the address information struct for the given address and session. More...
static int	find_ai_no_session_cb (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Find matching address info, ignoring sessions and expired addresses. More...
static struct AddressInfo *	find_ai_no_session (const struct GNUNET_HELLO_Address *address)
	Find the address information struct for the given address (ignoring sessions) More...
int	GST_ats_is_known (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Test if ATS knows about this address and session. More...
int	GST_ats_is_known_no_session (const struct GNUNET_HELLO_Address *address)
	Test if ATS knows about this address. More...
static void	unblock_address (void *cls)
	The blocking time for an address has expired, allow ATS to suggest it again. More...
void	GST_ats_block_address (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Temporarily block a valid address for use by ATS for address suggestions. More...
void	GST_ats_block_reset (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Reset address blocking time. More...
void	GST_ats_add_inbound_address (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_ATS_Properties *prop)
	Notify ATS about a new inbound address. More...
void	GST_ats_add_address (const struct GNUNET_HELLO_Address *address, const struct GNUNET_ATS_Properties *prop)
	Notify ATS about a new address including the network the address is located in. More...
void	GST_ats_new_session (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Notify ATS about a new session now existing for the given address. More...
static void	destroy_ai (struct AddressInfo *ai)
	Release memory used by the given address data. More...
void	GST_ats_del_session (const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
	Notify ATS that the session (but not the address) of a given address is no longer relevant. More...
void	GST_ats_update_distance (const struct GNUNET_HELLO_Address *address, uint32_t distance)
	Notify ATS about DV distance change to an address. More...
void	GST_ats_update_delay (const struct GNUNET_HELLO_Address *address, struct GNUNET_TIME_Relative delay)
	Notify ATS about delay changes to properties of an address. More...
void	GST_ats_update_utilization (const struct GNUNET_HELLO_Address *address, uint32_t bps_in, uint32_t bps_out)
	Notify ATS about utilization changes to an address. More...
void	GST_ats_expire_address (const struct GNUNET_HELLO_Address *address)
	Notify ATS that the address has expired and thus cannot be used any longer. More...
void	GST_ats_init ()
	Initialize ATS subsystem. More...
static int	destroy_ai_cb (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Release memory used by the given address data. More...
void	GST_ats_done ()
	Shutdown ATS subsystem. More...

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	p2a
	Map from peer identities to one or more struct AddressInfo values for the peer. More...
static unsigned int	num_blocked
	Number of blocked addresses. More...

Detailed Description

interfacing between transport and ATS service

Author

Christian Grothoff

Definition in file gnunet-service-transport_ats.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "transport-ats", __VA_ARGS__)

Log convenience function.

Definition at line 35 of file gnunet-service-transport_ats.c.

Function Documentation

publish_p2a_stat_update()

static void publish_p2a_stat_update ( )

static

Provide an update on the p2a map size to statistics.

This function should be called whenever the p2a map is changed.

Definition at line 134 of file gnunet-service-transport_ats.c.

{
  GNUNET_STATISTICS_set (GST_stats,
                         gettext_noop ("# Addresses given to ATS"),
                         GNUNET_CONTAINER_multipeermap_size (p2a) - num_blocked,
                         GNUNET_NO);
  GNUNET_STATISTICS_set (GST_stats,
                         "# blocked addresses",
                         num_blocked,
                         GNUNET_NO);
}

References gettext_noop, GNUNET_CONTAINER_multipeermap_size(), GNUNET_NO, GNUNET_STATISTICS_set(), GST_stats, num_blocked, and p2a.

Referenced by destroy_ai(), GST_ats_add_address(), GST_ats_add_inbound_address(), GST_ats_block_address(), GST_ats_done(), and unblock_address().

Here is the call graph for this function:

Here is the caller graph for this function:

find_ai_cb()

static int find_ai_cb ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Find matching address info.

Both the address and the session must match; note that expired addresses are still found (as the session kind-of keeps those alive).

Parameters

cls	the struct FindClosure
key	which peer is this about
value	the struct AddressInfo

Returns

GNUNET_YES to continue to iterate, GNUNET_NO if we found the value

Definition at line 158 of file gnunet-service-transport_ats.c.

{
  struct FindClosure *fc = cls;
  struct AddressInfo *ai = value;
 
  if ((0 ==
       GNUNET_HELLO_address_cmp (fc->address,
                                 ai->address)) &&
      (fc->session == ai->session))
  {
    fc->ret = ai;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References FindClosure::address, GNUNET_TRANSPORT_AddressIdentifier::address, ai, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_YES, FindClosure::ret, FindClosure::session, and value.

Referenced by find_ai().

Here is the call graph for this function:

Here is the caller graph for this function:

find_ai()

static struct AddressInfo* find_ai ( const struct GNUNET_HELLO_Address *  address, struct GNUNET_ATS_Session *  session  )

static

Find the address information struct for the given address and session.

Parameters

address	address to look for
session	session to match for inbound connections

Returns

NULL if this combination is unknown

Definition at line 186 of file gnunet-service-transport_ats.c.

{
  struct FindClosure fc;
 
  fc.address = address;
  fc.session = session;
  fc.ret = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (p2a,
                                              &address->peer,
                                              &find_ai_cb,
                                              &fc);
  return fc.ret;
}

References address, FindClosure::address, find_ai_cb(), GNUNET_CONTAINER_multipeermap_get_multiple(), p2a, FindClosure::ret, and FindClosure::session.

Referenced by GST_ats_add_inbound_address(), GST_ats_block_address(), GST_ats_block_reset(), GST_ats_del_session(), GST_ats_is_known(), and GST_ats_new_session().

Here is the call graph for this function:

Here is the caller graph for this function:

find_ai_no_session_cb()

static int find_ai_no_session_cb ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Find matching address info, ignoring sessions and expired addresses.

Parameters

cls	the struct FindClosure
key	which peer is this about
value	the struct AddressInfo

Returns

GNUNET_YES to continue to iterate, GNUNET_NO if we found the value

Definition at line 212 of file gnunet-service-transport_ats.c.

{
  struct FindClosure *fc = cls;
  struct AddressInfo *ai = value;
 
  if (ai->expired)
    return GNUNET_YES; /* expired do not count here */
  if (0 ==
      GNUNET_HELLO_address_cmp (fc->address,
                                ai->address))
  {
    fc->ret = ai;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References FindClosure::address, GNUNET_TRANSPORT_AddressIdentifier::address, ai, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_YES, FindClosure::ret, and value.

Referenced by find_ai_no_session().

Here is the call graph for this function:

Here is the caller graph for this function:

find_ai_no_session()

static struct AddressInfo* find_ai_no_session ( const struct GNUNET_HELLO_Address *  address )

static

Find the address information struct for the given address (ignoring sessions)

Parameters

address

address to look for

Returns

NULL if this combination is unknown

Definition at line 240 of file gnunet-service-transport_ats.c.

{
  struct FindClosure fc;
 
  fc.address = address;
  fc.session = NULL;
  fc.ret = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (p2a,
                                              &address->peer,
                                              &find_ai_no_session_cb,
                                              &fc);
  return fc.ret;
}

References address, FindClosure::address, find_ai_no_session_cb(), GNUNET_CONTAINER_multipeermap_get_multiple(), p2a, FindClosure::ret, and FindClosure::session.

Referenced by GST_ats_add_address(), GST_ats_expire_address(), GST_ats_is_known_no_session(), 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:

GST_ats_is_known()

int GST_ats_is_known	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Test if ATS knows about this address and session.

Note that even if the address is expired, we return GNUNET_YES if the respective session matches.

Parameters

address	the address
session	the session

Returns

GNUNET_YES if address is known, GNUNET_NO if not.

Definition at line 265 of file gnunet-service-transport_ats.c.

{
  return (NULL != find_ai (address, session)) ? GNUNET_YES : GNUNET_NO;
}

References address, find_ai(), GNUNET_NO, GNUNET_YES, and FindClosure::session.

Referenced by GST_neighbours_session_terminated(), send_with_session(), set_primary_address(), and try_run_fast_ats_update().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_is_known_no_session()

int GST_ats_is_known_no_session

(

const struct GNUNET_HELLO_Address *

address

)

Test if ATS knows about this address.

Note that expired addresses do not count.

Parameters

address

the address

Returns

GNUNET_YES if address is known, GNUNET_NO if not.

Definition at line 280 of file gnunet-service-transport_ats.c.

{
  return (NULL != find_ai_no_session (address))
         ? GNUNET_YES
         : GNUNET_NO;
}

References address, find_ai_no_session(), GNUNET_NO, and GNUNET_YES.

Referenced by add_valid_address(), cleanup_validation_entry(), find_validation_entry(), and GST_validation_handle_pong().

Here is the call graph for this function:

Here is the caller graph for this function:

unblock_address()

static void unblock_address ( void *  cls )

static

The blocking time for an address has expired, allow ATS to suggest it again.

Parameters

cls	the struct AddressInfo of the address to unblock

Definition at line 295 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai = cls;
 
  ai->unblock_task = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Unblocking address %s of peer %s\n",
       GST_plugins_a2s (ai->address),
       GNUNET_i2s (&ai->address->peer));
  ai->ar = GNUNET_ATS_address_add (GST_ats,
                                   ai->address,
                                   ai->session,
                                   &ai->properties);
  GNUNET_break (NULL != ai->ar);
  num_blocked--;
  publish_p2a_stat_update ();
}

References GNUNET_TRANSPORT_AddressIdentifier::address, ai, GNUNET_ATS_address_add(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_ats, GST_plugins_a2s(), LOG, num_blocked, and publish_p2a_stat_update().

Referenced by GST_ats_block_address().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_block_address()

void GST_ats_block_address	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Temporarily block a valid address for use by ATS for address suggestions.

This function should be called if an address was suggested by ATS but failed to perform (i.e. failure to establish a session or to exchange the PING/PONG).

Parameters

address	the address to block
session	the session (can be NULL)

Definition at line 324 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
  ai = find_ai (address,
                session);
  if ((NULL == ai) || (NULL == ai->ar))
  {
    /* The address is already gone/blocked, this can happen during a blacklist
     * callback. */
    return;
  }
  ai->back_off = GNUNET_TIME_STD_BACKOFF (ai->back_off);
  if (GNUNET_YES ==
      GNUNET_HELLO_address_check_option (address,
                                         GNUNET_HELLO_ADDRESS_INFO_INBOUND))
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Removing address %s of peer %s from use (inbound died)\n",
         GST_plugins_a2s (address),
         GNUNET_i2s (&address->peer));
  else
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Blocking address %s of peer %s from use for %s\n",
         GST_plugins_a2s (address),
         GNUNET_i2s (&address->peer),
         GNUNET_STRINGS_relative_time_to_string (ai->back_off,
                                                 GNUNET_YES));
  /* destroy session and address */
  if ((NULL == session) ||
      (GNUNET_NO ==
       GNUNET_ATS_address_del_session (ai->ar,
                                       session)))
  {
    GNUNET_ATS_address_destroy (ai->ar);
  }
  /* "ar" has been freed, regardless how the branch
     above played out: it was either freed in
   #GNUNET_ATS_address_del_session() because it was
     incoming, or explicitly in
   #GNUNET_ATS_address_del_session(). */ai->ar = NULL;
 
  /* determine when the address should come back to life */
  ai->blocked = GNUNET_TIME_relative_to_absolute (ai->back_off);
  ai->unblock_task = GNUNET_SCHEDULER_add_delayed (ai->back_off,
                                                   &unblock_address,
                                                   ai);
  num_blocked++;
  publish_p2a_stat_update ();
}

References address, ai, find_ai(), GNUNET_ATS_address_del_session(), GNUNET_ATS_address_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, GST_my_identity, GST_plugins_a2s(), LOG, num_blocked, publish_p2a_stat_update(), AddressInfo::session, and unblock_address().

Referenced by free_address(), GST_neighbours_switch_to_address(), set_primary_address(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_block_reset()

void GST_ats_block_reset	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Reset address blocking time.

Resets the exponential back-off timer for this address to zero. Called when an address was used to create a successful connection.

Parameters

address	the address to reset the blocking timer
session	the session (can be NULL)

Definition at line 390 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
  ai = find_ai (address, session);
  if (NULL == ai)
  {
    GNUNET_break (0);
    return;
  }
  /* address is in successful use, so it should not be blocked right now */
  GNUNET_break (NULL == ai->unblock_task);
  ai->back_off = GNUNET_TIME_UNIT_ZERO;
}

References address, ai, find_ai(), GNUNET_break, GNUNET_TIME_UNIT_ZERO, GST_my_identity, and AddressInfo::session.

Referenced by GST_neighbours_handle_session_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_add_inbound_address()

void GST_ats_add_inbound_address	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session,
		const struct GNUNET_ATS_Properties *	prop
	)

Notify ATS about a new inbound address.

The address in combination with the session must be new, but this function will perform a santiy check. If the address is indeed new, make it available to ATS.

Parameters

address	the address
session	the session
prop	performance information

Definition at line 423 of file gnunet-service-transport_ats.c.

{
  struct GNUNET_ATS_AddressRecord *ar;
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
 
  /* Sanity checks for a valid inbound address */
  if (NULL == address->transport_name)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_HELLO_address_check_option (address,
                                                    GNUNET_HELLO_ADDRESS_INFO_INBOUND));
  GNUNET_assert (NULL != session);
  ai = find_ai (address, session);
  if (NULL != ai)
  {
    /* This should only be called for new sessions, and thus
       we should not already have the address */
    GNUNET_break (0);
    return;
  }
  /* Is indeed new, let's tell ATS */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying ATS about peer `%s''s new inbound address `%s' session %p in network %s\n",
       GNUNET_i2s (&address->peer),
       GST_plugins_a2s (address),
       session,
       GNUNET_NT_to_string (prop->scope));
  ar = GNUNET_ATS_address_add (GST_ats,
                               address,
                               session,
                               prop);
  GNUNET_assert (NULL != ar);
  ai = GNUNET_new (struct AddressInfo);
  ai->address = GNUNET_HELLO_address_copy (address);
  ai->session = session;
  ai->properties = *prop;
  ai->ar = ar;
  (void) GNUNET_CONTAINER_multipeermap_put (p2a,
                                            &ai->address->peer,
                                            ai,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  publish_p2a_stat_update ();
}

References address, GNUNET_TRANSPORT_AddressIdentifier::address, ai, AddressInfo::ar, find_ai(), GNUNET_assert, GNUNET_ATS_address_add(), GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_address_copy(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_new, GNUNET_NT_to_string(), GNUNET_NT_UNSPECIFIED, GNUNET_YES, GST_ats, GST_my_identity, GST_plugins_a2s(), LOG, p2a, publish_p2a_stat_update(), GNUNET_ATS_Properties::scope, and AddressInfo::session.

Referenced by plugin_env_session_start().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_add_address()

void GST_ats_add_address	(	const struct GNUNET_HELLO_Address *	address,
		const struct GNUNET_ATS_Properties *	prop
	)

Notify ATS about a new address including the network the address is located in.

The address must NOT be inbound and must be new to ATS.

Parameters

address	the address
prop	performance information

Definition at line 481 of file gnunet-service-transport_ats.c.

{
  struct GNUNET_ATS_AddressRecord *ar;
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
  /* validadte address */
  if (NULL == address->transport_name)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_assert (GNUNET_YES !=
                 GNUNET_HELLO_address_check_option (address,
                                                    GNUNET_HELLO_ADDRESS_INFO_INBOUND));
  ai = find_ai_no_session (address);
  GNUNET_assert (NULL == ai);
  GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
 
  /* address seems sane, let's tell ATS */
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Notifying ATS about peer %s's new address `%s'\n",
       GNUNET_i2s (&address->peer),
       GST_plugins_a2s (address));
  ar = GNUNET_ATS_address_add (GST_ats,
                               address,
                               NULL,
                               prop);
  GNUNET_assert (NULL != ar);
  ai = GNUNET_new (struct AddressInfo);
  ai->address = GNUNET_HELLO_address_copy (address);
  ai->ar = ar;
  ai->properties = *prop;
  (void) GNUNET_CONTAINER_multipeermap_put (p2a,
                                            &ai->address->peer,
                                            ai,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  publish_p2a_stat_update ();
}

References address, GNUNET_TRANSPORT_AddressIdentifier::address, ai, AddressInfo::ar, find_ai_no_session(), GNUNET_assert, GNUNET_ATS_address_add(), GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_address_copy(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_new, GNUNET_NT_UNSPECIFIED, GNUNET_YES, GST_ats, GST_my_identity, GST_plugins_a2s(), LOG, p2a, publish_p2a_stat_update(), and GNUNET_ATS_Properties::scope.

Referenced by add_valid_address(), and GST_validation_handle_pong().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_new_session()

void GST_ats_new_session	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Notify ATS about a new session now existing for the given address.

Essentially, an outbound address was used to establish a session. It is safe to call this function repeatedly for the same address and session pair.

Parameters

address	the address
session	the session

Definition at line 537 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
  ai = find_ai (address, NULL);
  if (NULL == ai)
  {
    /* We may simply already be aware of the session, even if some
       other part of the code could not tell if it just created a new
       session or just got one recycled from the plugin; hence, we may
       be called with "new" session even for an "old" session; in that
       case, check that this is the case, but just ignore it. */GNUNET_assert (NULL != (find_ai (address, session)));
    return;
  }
  GNUNET_assert (NULL == ai->session);
  ai->session = session;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Telling ATS about new session for peer %s\n",
       GNUNET_i2s (&address->peer));
  /* Note that the address might currently be blocked; we only
     tell ATS about the session if the address is currently not
     blocked; otherwise, ATS will be told about the session on
     unblock. */
  if (NULL != ai->ar)
    GNUNET_ATS_address_add_session (ai->ar,
                                    session);
  else
    GNUNET_assert (NULL != ai->unblock_task);
}

References address, ai, find_ai(), GNUNET_assert, GNUNET_ATS_address_add_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_my_identity, LOG, and AddressInfo::session.

Referenced by multicast_pong(), send_syn_ack_message(), send_with_session(), and switch_address_bl_check_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_ai()

static void destroy_ai ( struct AddressInfo *  ai )

static

Release memory used by the given address data.

Parameters

ai	the struct AddressInfo

Definition at line 580 of file gnunet-service-transport_ats.c.

{
  GNUNET_assert (NULL == ai->session);
  if (NULL != ai->unblock_task)
  {
    GNUNET_SCHEDULER_cancel (ai->unblock_task);
    ai->unblock_task = NULL;
    num_blocked--;
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (p2a,
                                                       &ai->address->peer,
                                                       ai));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Telling ATS to destroy address from peer %s\n",
       GNUNET_i2s (&ai->address->peer));
  if (NULL != ai->ar)
  {
    GNUNET_ATS_address_destroy (ai->ar);
    ai->ar = NULL;
  }
  publish_p2a_stat_update ();
  GNUNET_HELLO_address_free (ai->address);
  GNUNET_free (ai);
}

References GNUNET_TRANSPORT_AddressIdentifier::address, ai, GNUNET_assert, GNUNET_ATS_address_destroy(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_i2s(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, LOG, num_blocked, p2a, and publish_p2a_stat_update().

Referenced by destroy_ai_cb(), GST_ats_del_session(), and GST_ats_expire_address().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_del_session()

void GST_ats_del_session	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_ATS_Session *	session
	)

Notify ATS that the session (but not the address) of a given address is no longer relevant.

(The session went down.) This function may be called even if for the respective outbound address GST_ats_new_session() was never called and thus the pair is unknown to ATS. In this case, the call is simply ignored.

Parameters

address	the address
session	the session

Definition at line 619 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
  if (NULL == session)
  {
    GNUNET_break (0);
    return;
  }
  ai = find_ai (address,
                session);
  if (NULL == ai)
  {
    /* We sometimes create sessions just for sending a PING,
       and if those are destroyed they were never known to
       ATS which means we end up here (however, in this
       case, the address must be an outbound address). */
    GNUNET_break (GNUNET_YES !=
                  GNUNET_HELLO_address_check_option (address,
                                                     GNUNET_HELLO_ADDRESS_INFO_INBOUND));
    return;
  }
  GNUNET_assert (session == ai->session);
  ai->session = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Telling ATS to destroy session %p from peer %s\n",
       session,
       GNUNET_i2s (&address->peer));
  if (GNUNET_YES == ai->expired)
  {
    /* last reason to keep this 'ai' around is now gone, the
       session is dead as well, clean up */
    if (NULL != ai->ar)
    {
      /* Address expired but not blocked, and thus 'ar' was still
         live because of the session; deleting just the session
         will do for an inbound session, but for an outbound we
         then also need to destroy the address with ATS. */
      if (GNUNET_NO ==
          GNUNET_ATS_address_del_session (ai->ar,
                                          session))
      {
        GNUNET_ATS_address_destroy (ai->ar);
      }
      /* "ar" has been freed, regardless how the branch
         above played out: it was either freed in
       #GNUNET_ATS_address_del_session() because it was
         incoming, or explicitly in
       #GNUNET_ATS_address_del_session(). */ai->ar = NULL;
    }
    destroy_ai (ai);
    return;
  }
 
  if (NULL == ai->ar)
  {
    /* If ATS doesn't know about the address/session, this means
       this address was blocked. */
    if (GNUNET_YES ==
        GNUNET_HELLO_address_check_option (address,
                                           GNUNET_HELLO_ADDRESS_INFO_INBOUND))
    {
      /* This was a blocked inbound session, which now lost the
         session.  But inbound addresses are by themselves useless,
         so we must forget about the address as well. */
      destroy_ai (ai);
      return;
    }
    /* Otherwise, we are done as we have set `ai->session` to NULL
       already and ATS will simply not be told about the session when
       the connection is unblocked and the outbound address becomes
       available again. . */
    return;
  }
 
  /* This is the "simple" case where ATS knows about the session and
     the address is neither blocked nor expired.  Delete the session,
     and if it was inbound, free the address as well. */
  if (GNUNET_YES ==
      GNUNET_ATS_address_del_session (ai->ar,
                                      session))
  {
    /* This was an inbound address, the session is now gone, so we
       need to also forget about the address itself. */
    ai->ar = NULL;
    destroy_ai (ai);
  }
}

References address, ai, destroy_ai(), find_ai(), GNUNET_assert, GNUNET_ATS_address_del_session(), GNUNET_ATS_address_destroy(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_check_option(), GNUNET_HELLO_ADDRESS_INFO_INBOUND, GNUNET_i2s(), GNUNET_NO, GNUNET_YES, GST_my_identity, LOG, and AddressInfo::session.

Referenced by plugin_env_session_end().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_update_distance()

void GST_ats_update_distance	(	const struct GNUNET_HELLO_Address *	address,
		uint32_t	distance
	)

Notify ATS about DV distance change to an address.

Does nothing if the address is not known to us.

Parameters

address	the address
distance	new distance value

Definition at line 723 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  ai = find_ai_no_session (address);
  if (NULL == ai)
  {
    /* We do not know about this address, do nothing. */
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updated distance for peer `%s' to %u\n",
       GNUNET_i2s (&address->peer),
       distance);
  ai->properties.distance = distance;
  /* Give manipulation its chance to change metrics */
  GST_manipulation_manipulate_metrics (address,
                                       ai->session,
                                       &ai->properties);
  /* Address may be blocked, only give ATS if address is
     currently active. */
  if (NULL != ai->ar)
    GNUNET_ATS_address_update (ai->ar,
                               &ai->properties);
}

References address, ai, find_ai_no_session(), GNUNET_ATS_address_update(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_manipulation_manipulate_metrics(), and LOG.

Referenced by plugin_env_address_to_type().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_update_delay()

void GST_ats_update_delay	(	const struct GNUNET_HELLO_Address *	address,
		struct GNUNET_TIME_Relative	delay
	)

Notify ATS about delay changes to properties of an address.

Does nothing if the address is not known to us.

Parameters

address	the address
delay	new delay value

Definition at line 752 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  ai = find_ai_no_session (address);
  if (NULL == ai)
  {
    /* We do not know about this address, do nothing. */
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updated latency for peer `%s' to %s\n",
       GNUNET_i2s (&address->peer),
       GNUNET_STRINGS_relative_time_to_string (delay,
                                               GNUNET_YES));
  ai->properties.delay = delay;
  /* Give manipulation its chance to change metrics */
  GST_manipulation_manipulate_metrics (address,
                                       ai->session,
                                       &ai->properties);
  /* Address may be blocked, only give ATS if address is
     currently active. */
  if (NULL != ai->ar)
    GNUNET_ATS_address_update (ai->ar,
                               &ai->properties);
}

References address, ai, delay, find_ai_no_session(), GNUNET_ATS_address_update(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, GST_manipulation_manipulate_metrics(), and LOG.

Referenced by GST_neighbours_calculate_receive_delay(), and GST_validation_handle_pong().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_update_utilization()

void GST_ats_update_utilization	(	const struct GNUNET_HELLO_Address *	address,
		uint32_t	bps_in,
		uint32_t	bps_out
	)

Notify ATS about utilization changes to an address.

Does nothing if the address is not known to us.

Parameters

address	our information about the address
bps_in	new utilization inbound
bps_out	new utilization outbound

Definition at line 790 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  ai = find_ai_no_session (address);
  if (NULL == ai)
  {
    /* We do not know about this address, do nothing. */
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Updating utilization for peer `%s' address %s: %u/%u\n",
       GNUNET_i2s (&address->peer),
       GST_plugins_a2s (address),
       (unsigned int) bps_in,
       (unsigned int) bps_out);
  ai->properties.utilization_in = bps_in;
  ai->properties.utilization_out = bps_out;
  /* Give manipulation its chance to change metrics */
  GST_manipulation_manipulate_metrics (address,
                                       ai->session,
                                       &ai->properties);
  /* Address may be blocked, only give ATS if address is
     currently active. */
  if (NULL != ai->ar)
    GNUNET_ATS_address_update (ai->ar,
                               &ai->properties);
}

References address, ai, find_ai_no_session(), GNUNET_ATS_address_update(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_manipulation_manipulate_metrics(), GST_plugins_a2s(), and LOG.

Referenced by send_utilization_data().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_expire_address()

void GST_ats_expire_address

(

const struct GNUNET_HELLO_Address *

address

)

Notify ATS that the address has expired and thus cannot be used any longer.

This function must only be called if the corresponding session is already gone.

Parameters

address

the address

Definition at line 830 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai;
 
  if (0 ==
      memcmp (&GST_my_identity,
              &address->peer,
              sizeof(struct GNUNET_PeerIdentity)))
    return; /* our own, ignore! */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Address %s of peer %s expired\n",
       GST_plugins_a2s (address),
       GNUNET_i2s (&address->peer));
  ai = find_ai_no_session (address);
  if (NULL == ai)
  {
    GNUNET_assert (0);
    return;
  }
  if (NULL != ai->session)
  {
    /* Got an active session, just remember the expiration
       and act upon it when the session goes down. */
    ai->expired = GNUNET_YES;
    return;
  }
  /* Address expired, no session, free resources */
  destroy_ai (ai);
}

References address, ai, destroy_ai(), find_ai_no_session(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, GST_my_identity, GST_plugins_a2s(), and LOG.

Referenced by cleanup_validation_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_init()

void GST_ats_init

(

void

)

Initialize ATS subsystem.

Definition at line 865 of file gnunet-service-transport_ats.c.

{
  p2a = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_YES);
}

References GNUNET_CONTAINER_multipeermap_create(), GNUNET_YES, and p2a.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_ai_cb()

static int destroy_ai_cb ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Release memory used by the given address data.

Parameters

cls	NULL
key	which peer is this about
value	the struct AddressInfo

Returns

GNUNET_OK (continue to iterate)

Definition at line 880 of file gnunet-service-transport_ats.c.

{
  struct AddressInfo *ai = value;
 
  destroy_ai (ai);
  return GNUNET_OK;
}

References ai, destroy_ai(), GNUNET_OK, and value.

Referenced by GST_ats_done().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_ats_done()

void GST_ats_done

(

void

)

Shutdown ATS subsystem.

Definition at line 895 of file gnunet-service-transport_ats.c.

{
  GNUNET_CONTAINER_multipeermap_iterate (p2a,
                                         &destroy_ai_cb,
                                         NULL);
  publish_p2a_stat_update ();
  GNUNET_CONTAINER_multipeermap_destroy (p2a);
  p2a = NULL;
}

References destroy_ai_cb(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), p2a, and publish_p2a_stat_update().

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

p2a

struct GNUNET_CONTAINER_MultiPeerMap* p2a

static

Map from peer identities to one or more struct AddressInfo values for the peer.

Definition at line 98 of file gnunet-service-transport_ats.c.

Referenced by destroy_ai(), find_ai(), find_ai_no_session(), GST_ats_add_address(), GST_ats_add_inbound_address(), GST_ats_done(), GST_ats_init(), and publish_p2a_stat_update().

num_blocked

unsigned int num_blocked

static

Number of blocked addresses.

Definition at line 103 of file gnunet-service-transport_ats.c.

Referenced by destroy_ai(), GST_ats_block_address(), publish_p2a_stat_update(), and unblock_address().