gnunet-service-transport_ats.h File Reference

interfacing between transport and ATS service More...

#include "gnunet_ats_service.h"

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

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	GST_ats_init (void)
	Initialize ATS subsystem. More...
void	GST_ats_done (void)
	Shutdown ATS subsystem. 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...
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 this 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...
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_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_distance (const struct GNUNET_HELLO_Address *address, uint32_t distance)
	Notify ATS about DV distance change to an address. 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_expire_address (const struct GNUNET_HELLO_Address *address)
	Notify ATS that the address has expired and thus cannot be used any longer. More...

Detailed Description

interfacing between transport and ATS service

Author

Christian Grothoff

Definition in file gnunet-service-transport_ats.h.

Function Documentation

GST_ats_init()

void GST_ats_init

(

void

)

Initialize ATS subsystem.

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

References GNUNET_CONTAINER_multipeermap_create(), and GNUNET_YES.

Referenced by run().

{
  p2a = GNUNET_CONTAINER_multipeermap_create(4, GNUNET_YES);
}

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 910 of file gnunet-service-transport_ats.c.

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

Referenced by shutdown_task().

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

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 263 of file gnunet-service-transport_ats.c.

References find_ai(), GNUNET_NO, and GNUNET_YES.

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

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

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 278 of file gnunet-service-transport_ats.c.

References 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().

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

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 322 of file gnunet-service-transport_ats.c.

References ai, AddressInfo::ar, AddressInfo::back_off, AddressInfo::blocked, 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, GNUNET_HELLO_Address::peer, publish_p2a_stat_update(), unblock_address(), and AddressInfo::unblock_task.

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

{
  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();
}

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 389 of file gnunet-service-transport_ats.c.

References ai, AddressInfo::back_off, find_ai(), GNUNET_break, GNUNET_TIME_UNIT_ZERO, GST_my_identity, GNUNET_HELLO_Address::peer, and AddressInfo::unblock_task.

Referenced by GST_neighbours_handle_session_ack().

{
  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;
}

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 422 of file gnunet-service-transport_ats.c.

References AddressInfo::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, GNUNET_HELLO_Address::peer, AddressInfo::properties, publish_p2a_stat_update(), GNUNET_ATS_Properties::scope, AddressInfo::session, and GNUNET_HELLO_Address::transport_name.

Referenced by plugin_env_session_start().

{
  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();
}

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 this address is located in.

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

Parameters

address	the address
prop	performance information

Notify ATS about a new address including the network this 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 487 of file gnunet-service-transport_ats.c.

References AddressInfo::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, GNUNET_HELLO_Address::peer, AddressInfo::properties, publish_p2a_stat_update(), GNUNET_ATS_Properties::scope, and GNUNET_HELLO_Address::transport_name.

Referenced by add_valid_address(), and GST_validation_handle_pong().

{
  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();
}

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 543 of file gnunet-service-transport_ats.c.

References ai, AddressInfo::ar, find_ai(), GNUNET_assert, GNUNET_ATS_address_add_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_my_identity, LOG, GNUNET_HELLO_Address::peer, AddressInfo::session, and AddressInfo::unblock_task.

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

{
  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);
}

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 805 of file gnunet-service-transport_ats.c.

References ai, AddressInfo::ar, find_ai_no_session(), GNUNET_ATS_address_update(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_manipulation_manipulate_metrics(), GST_plugins_a2s(), LOG, GNUNET_HELLO_Address::peer, AddressInfo::properties, AddressInfo::session, GNUNET_ATS_Properties::utilization_in, and GNUNET_ATS_Properties::utilization_out.

Referenced by send_utilization_data().

{
  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);
}

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
session	the session
delay	new delay value

Does nothing if the address is not known to us.

Parameters

address	the address
delay	new delay value

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

References ai, AddressInfo::ar, delay, GNUNET_ATS_Properties::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(), LOG, GNUNET_HELLO_Address::peer, AddressInfo::properties, and AddressInfo::session.

Referenced by GST_neighbours_keepalive_response(), and GST_validation_handle_pong().

{
  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);
}

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 731 of file gnunet-service-transport_ats.c.

References ai, AddressInfo::ar, GNUNET_ATS_Properties::distance, find_ai_no_session(), GNUNET_ATS_address_update(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_manipulation_manipulate_metrics(), LOG, GNUNET_HELLO_Address::peer, AddressInfo::properties, and AddressInfo::session.

Referenced by plugin_env_update_distance().

{
  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);
}

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 626 of file gnunet-service-transport_ats.c.

References ai, AddressInfo::ar, destroy_ai(), AddressInfo::expired, 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, GNUNET_HELLO_Address::peer, and AddressInfo::session.

Referenced by plugin_env_session_end().

{
  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);
    }
}

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 845 of file gnunet-service-transport_ats.c.

References ai, destroy_ai(), AddressInfo::expired, find_ai_no_session(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_YES, GST_my_identity, GST_plugins_a2s(), LOG, GNUNET_HELLO_Address::peer, and AddressInfo::session.

Referenced by cleanup_validation_entry().

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function: