GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
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 AddressInfofind_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 AddressInfofind_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 the 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...
 
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_MultiPeerMapp2a
 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__)

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.

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

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

135 {
137  gettext_noop ("# Addresses given to ATS"),
139  GNUNET_NO);
141  "# blocked addresses",
142  num_blocked,
143  GNUNET_NO);
144 }
static unsigned int num_blocked
Number of blocked addresses.
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
#define gettext_noop(String)
Definition: gettext.h:69
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
clsthe struct FindClosure
keywhich peer is this about
valuethe 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.

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

Referenced by find_ai().

161 {
162  struct FindClosure *fc = cls;
163  struct AddressInfo *ai = value;
164 
165  if ((0 ==
167  ai->address)) &&
168  (fc->session == ai->session))
169  {
170  fc->ret = ai;
171  return GNUNET_NO;
172  }
173  return GNUNET_YES;
174 }
struct GNUNET_ATS_Session * session
Session to look for (only used if the address is inbound).
Closure for find_ai_cb() and find_ai_no_session_cb().
struct AddressInfo * ret
Where to store the result.
#define GNUNET_NO
Definition: gnunet_common.h:78
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
static char * value
Value of the record to add/remove.
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
const struct GNUNET_HELLO_Address * address
Address to look for.
struct GNUNET_HELLO_Address * address
The address (with peer identity).
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Session * session
Session (can be NULL)
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
addressaddress to look for
sessionsession to match for inbound connections
Returns
NULL if this combination is unknown

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

References AddressInfo::address, FindClosure::address, find_ai_cb(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_HELLO_Address::peer, FindClosure::ret, AddressInfo::session, 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().

188 {
189  struct FindClosure fc;
190 
191  fc.address = address;
192  fc.session = session;
193  fc.ret = NULL;
195  &address->peer,
196  &find_ai_cb,
197  &fc);
198  return fc.ret;
199 }
struct GNUNET_ATS_Session * session
Session to look for (only used if the address is inbound).
Closure for find_ai_cb() and find_ai_no_session_cb().
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
const struct GNUNET_HELLO_Address * address
Address to look for.
static int find_ai_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find matching address info.
static char * address
GNS address for this phone.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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
clsthe struct FindClosure
keywhich peer is this about
valuethe 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.

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

Referenced by find_ai_no_session().

215 {
216  struct FindClosure *fc = cls;
217  struct AddressInfo *ai = value;
218 
219  if (ai->expired)
220  return GNUNET_YES; /* expired do not count here */
221  if (0 ==
223  ai->address))
224  {
225  fc->ret = ai;
226  return GNUNET_NO;
227  }
228  return GNUNET_YES;
229 }
Closure for find_ai_cb() and find_ai_no_session_cb().
struct AddressInfo * ret
Where to store the result.
#define GNUNET_NO
Definition: gnunet_common.h:78
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
static char * value
Value of the record to add/remove.
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
const struct GNUNET_HELLO_Address * address
Address to look for.
struct GNUNET_HELLO_Address * address
The address (with peer identity).
#define GNUNET_YES
Definition: gnunet_common.h:77
int expired
Set to GNUNET_YES if the address has expired but we could not yet remove it because we still have a v...
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
addressaddress to look for
Returns
NULL if this combination is unknown

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

References AddressInfo::address, FindClosure::address, find_ai_no_session_cb(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_HELLO_Address::peer, 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().

241 {
242  struct FindClosure fc;
243 
244  fc.address = address;
245  fc.session = NULL;
246  fc.ret = NULL;
248  &address->peer,
250  &fc);
251  return fc.ret;
252 }
Closure for find_ai_cb() and find_ai_no_session_cb().
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
const struct GNUNET_HELLO_Address * address
Address to look for.
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.
static char * address
GNS address for this phone.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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
addressthe address
sessionthe session
Returns
GNUNET_YES if address is known, GNUNET_NO if not.

Definition at line 265 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().

267 {
268  return (NULL != find_ai (address, session)) ? GNUNET_YES : GNUNET_NO;
269 }
#define GNUNET_NO
Definition: gnunet_common.h:78
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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
addressthe address
Returns
GNUNET_YES if address is known, GNUNET_NO if not.

Definition at line 280 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().

281 {
282  return (NULL != find_ai_no_session (address))
283  ? GNUNET_YES
284  : GNUNET_NO;
285 }
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsthe struct AddressInfo of the address to unblock

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

References AddressInfo::address, ai, AddressInfo::ar, GNUNET_ATS_address_add(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GST_ats, GST_plugins_a2s(), LOG, num_blocked, GNUNET_HELLO_Address::peer, AddressInfo::properties, publish_p2a_stat_update(), AddressInfo::session, and AddressInfo::unblock_task.

Referenced by GST_ats_block_address().

296 {
297  struct AddressInfo *ai = cls;
298 
299  ai->unblock_task = NULL;
301  "Unblocking address %s of peer %s\n",
302  GST_plugins_a2s (ai->address),
303  GNUNET_i2s (&ai->address->peer));
305  ai->address,
306  ai->session,
307  &ai->properties);
308  GNUNET_break (NULL != ai->ar);
309  num_blocked--;
311 }
struct GNUNET_SCHEDULER_Task * unblock_task
Task scheduled to unblock an ATS-blocked address at blocked time, or NULL if the address is not block...
struct GNUNET_ATS_Properties properties
Performance properties of this address.
static unsigned int num_blocked
Number of blocked addresses.
struct GNUNET_ATS_SchedulingHandle * GST_ats
ATS scheduling handle.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
#define LOG(kind,...)
Log convenience function.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
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.
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_HELLO_Address * address
The address (with peer identity).
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
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
addressthe address to block
sessionthe session (can be NULL)

Definition at line 324 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().

326 {
327  struct AddressInfo *ai;
328 
329  if (0 ==
330  memcmp (&GST_my_identity,
331  &address->peer,
332  sizeof(struct GNUNET_PeerIdentity)))
333  return; /* our own, ignore! */
334  ai = find_ai (address,
335  session);
336  if ((NULL == ai) || (NULL == ai->ar))
337  {
338  /* The address is already gone/blocked, this can happen during a blacklist
339  * callback. */
340  return;
341  }
343  if (GNUNET_YES ==
347  "Removing address %s of peer %s from use (inbound died)\n",
348  GST_plugins_a2s (address),
349  GNUNET_i2s (&address->peer));
350  else
352  "Blocking address %s of peer %s from use for %s\n",
353  GST_plugins_a2s (address),
354  GNUNET_i2s (&address->peer),
356  GNUNET_YES));
357  /* destroy session and address */
358  if ((NULL == session) ||
359  (GNUNET_NO ==
361  session)))
362  {
364  }
365  /* "ar" has been freed, regardless how the branch
366  above played out: it was either freed in
367  #GNUNET_ATS_address_del_session() because it was
368  incoming, or explicitly in
369  #GNUNET_ATS_address_del_session(). */ai->ar = NULL;
370 
371  /* determine when the address should come back to life */
375  ai);
376  num_blocked++;
378 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
struct GNUNET_TIME_Relative back_off
If an address is blocked as part of an exponential back-off, we track the current size of the backoff...
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
struct GNUNET_SCHEDULER_Task * unblock_task
Task scheduled to unblock an ATS-blocked address at blocked time, or NULL if the address is not block...
static unsigned int num_blocked
Number of blocked addresses.
#define GNUNET_NO
Definition: gnunet_common.h:78
int GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
Check if an address has a local option set.
Definition: address.c:39
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
struct GNUNET_TIME_Absolute blocked
Time until when this address is blocked and should thus not be made available to ATS (ar should be NU...
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
#define LOG(kind,...)
Log convenience function.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
Information we track for each address known to ATS.
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.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static void unblock_address(void *cls)
The blocking time for an address has expired, allow ATS to suggest it again.
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
struct GNUNET_PeerIdentity peer
For which peer is this an address?
The identity of the host (wraps the signing key of the peer).
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.
void GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
An address got destroyed, stop using it as a valid address.
#define GNUNET_YES
Definition: gnunet_common.h:77
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
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
addressthe address to reset the blocking timer
sessionthe session (can be NULL)

Definition at line 390 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().

392 {
393  struct AddressInfo *ai;
394 
395  if (0 ==
396  memcmp (&GST_my_identity,
397  &address->peer,
398  sizeof(struct GNUNET_PeerIdentity)))
399  return; /* our own, ignore! */
400  ai = find_ai (address, session);
401  if (NULL == ai)
402  {
403  GNUNET_break (0);
404  return;
405  }
406  /* address is in successful use, so it should not be blocked right now */
407  GNUNET_break (NULL == ai->unblock_task);
409 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
struct GNUNET_TIME_Relative back_off
If an address is blocked as part of an exponential back-off, we track the current size of the backoff...
struct GNUNET_SCHEDULER_Task * unblock_task
Task scheduled to unblock an ATS-blocked address at blocked time, or NULL if the address is not block...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
The identity of the host (wraps the signing key of the peer).
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.
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
addressthe address
sessionthe session
propperformance information

Definition at line 423 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().

426 {
427  struct GNUNET_ATS_AddressRecord *ar;
428  struct AddressInfo *ai;
429 
430  if (0 ==
431  memcmp (&GST_my_identity,
432  &address->peer,
433  sizeof(struct GNUNET_PeerIdentity)))
434  return; /* our own, ignore! */
435 
436  /* Sanity checks for a valid inbound address */
437  if (NULL == address->transport_name)
438  {
439  GNUNET_break (0);
440  return;
441  }
446  GNUNET_assert (NULL != session);
447  ai = find_ai (address, session);
448  if (NULL != ai)
449  {
450  /* This should only be called for new sessions, and thus
451  we should not already have the address */
452  GNUNET_break (0);
453  return;
454  }
455  /* Is indeed new, let's tell ATS */
457  "Notifying ATS about peer `%s''s new inbound address `%s' session %p in network %s\n",
458  GNUNET_i2s (&address->peer),
459  GST_plugins_a2s (address),
460  session,
461  GNUNET_NT_to_string (prop->scope));
463  address,
464  session,
465  prop);
466  GNUNET_assert (NULL != ar);
467  ai = GNUNET_new (struct AddressInfo);
468  ai->address = GNUNET_HELLO_address_copy (address);
469  ai->session = session;
470  ai->properties = *prop;
471  ai->ar = ar;
473  &ai->address->peer,
474  ai,
477 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
const char * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:44
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_ATS_Properties properties
Performance properties of this address.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_ATS_SchedulingHandle * GST_ats
ATS scheduling handle.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
int GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
Check if an address has a local option set.
Definition: address.c:39
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
const char * transport_name
Name of the transport plugin enabling the communication using this address.
#define LOG(kind,...)
Log convenience function.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
Information we track per address, incoming or outgoing.
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.
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change...
Allow multiple values with the same key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The identity of the host (wraps the signing key of the peer).
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.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
struct GNUNET_HELLO_Address * address
The address (with peer identity).
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
Category of last resort.
Definition: gnunet_nt_lib.h:40
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 the new address including the network this address is located in.

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
addressthe address
propperformance information

Definition at line 488 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().

490 {
491  struct GNUNET_ATS_AddressRecord *ar;
492  struct AddressInfo *ai;
493 
494  if (0 ==
495  memcmp (&GST_my_identity,
496  &address->peer,
497  sizeof(struct GNUNET_PeerIdentity)))
498  return; /* our own, ignore! */
499  /* validadte address */
500  if (NULL == address->transport_name)
501  {
502  GNUNET_break (0);
503  return;
504  }
508  ai = find_ai_no_session (address);
509  GNUNET_assert (NULL == ai);
511 
512  /* address seems sane, let's tell ATS */
514  "Notifying ATS about peer %s's new address `%s'\n",
515  GNUNET_i2s (&address->peer),
516  GST_plugins_a2s (address));
518  address,
519  NULL,
520  prop);
521  GNUNET_assert (NULL != ar);
522  ai = GNUNET_new (struct AddressInfo);
523  ai->address = GNUNET_HELLO_address_copy (address);
524  ai->ar = ar;
525  ai->properties = *prop;
527  &ai->address->peer,
528  ai,
531 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_ATS_Properties properties
Performance properties of this address.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_ATS_SchedulingHandle * GST_ats
ATS scheduling handle.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
int GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
Check if an address has a local option set.
Definition: address.c:39
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
const char * transport_name
Name of the transport plugin enabling the communication using this address.
#define LOG(kind,...)
Log convenience function.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
Information we track per address, incoming or outgoing.
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.
Information we track for each address known to ATS.
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change...
Allow multiple values with the same key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
struct GNUNET_HELLO_Address * address
The address (with peer identity).
#define GNUNET_YES
Definition: gnunet_common.h:77
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
Category of last resort.
Definition: gnunet_nt_lib.h:40
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
addressthe address
sessionthe session

Definition at line 544 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().

546 {
547  struct AddressInfo *ai;
548 
549  if (0 ==
550  memcmp (&GST_my_identity,
551  &address->peer,
552  sizeof(struct GNUNET_PeerIdentity)))
553  return; /* our own, ignore! */
554  ai = find_ai (address, NULL);
555  if (NULL == ai)
556  {
557  /* We may simply already be aware of the session, even if some
558  other part of the code could not tell if it just created a new
559  session or just got one recycled from the plugin; hence, we may
560  be called with "new" session even for an "old" session; in that
561  case, check that this is the case, but just ignore it. */GNUNET_assert (NULL != (find_ai (address, session)));
562  return;
563  }
564  GNUNET_assert (NULL == ai->session);
565  ai->session = session;
567  "Telling ATS about new session for peer %s\n",
568  GNUNET_i2s (&address->peer));
569  /* Note that the address might currently be blocked; we only
570  tell ATS about the session if the address is currently not
571  blocked; otherwise, ATS will be told about the session on
572  unblock. */
573  if (NULL != ai->ar)
575  session);
576  else
577  GNUNET_assert (NULL != ai->unblock_task);
578 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * unblock_task
Task scheduled to unblock an ATS-blocked address at blocked time, or NULL if the address is not block...
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
#define LOG(kind,...)
Log convenience function.
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
The identity of the host (wraps the signing key of the peer).
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.
void GNUNET_ATS_address_add_session(struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
An address was used to initiate a session.
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
aithe struct AddressInfo

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

References AddressInfo::address, AddressInfo::ar, 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, GNUNET_HELLO_Address::peer, publish_p2a_stat_update(), AddressInfo::session, and AddressInfo::unblock_task.

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

588 {
589  GNUNET_assert (NULL == ai->session);
590  if (NULL != ai->unblock_task)
591  {
593  ai->unblock_task = NULL;
594  num_blocked--;
595  }
598  &ai->address->peer,
599  ai));
601  "Telling ATS to destroy address from peer %s\n",
602  GNUNET_i2s (&ai->address->peer));
603  if (NULL != ai->ar)
604  {
606  ai->ar = NULL;
607  }
610  GNUNET_free (ai);
611 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * unblock_task
Task scheduled to unblock an ATS-blocked address at blocked time, or NULL if the address is not block...
static unsigned int num_blocked
Number of blocked addresses.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
#define LOG(kind,...)
Log convenience function.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
void GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
An address got destroyed, stop using it as a valid address.
struct GNUNET_HELLO_Address * address
The address (with peer identity).
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_HELLO_address_free(addr)
Free an address.
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
addressthe address
sessionthe 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().

628 {
629  struct AddressInfo *ai;
630 
631  if (0 ==
632  memcmp (&GST_my_identity,
633  &address->peer,
634  sizeof(struct GNUNET_PeerIdentity)))
635  return; /* our own, ignore! */
636  if (NULL == session)
637  {
638  GNUNET_break (0);
639  return;
640  }
641  ai = find_ai (address,
642  session);
643  if (NULL == ai)
644  {
645  /* We sometimes create sessions just for sending a PING,
646  and if those are destroyed they were never known to
647  ATS which means we end up here (however, in this
648  case, the address must be an outbound address). */
652  return;
653  }
654  GNUNET_assert (session == ai->session);
655  ai->session = NULL;
657  "Telling ATS to destroy session %p from peer %s\n",
658  session,
659  GNUNET_i2s (&address->peer));
660  if (GNUNET_YES == ai->expired)
661  {
662  /* last reason to keep this 'ai' around is now gone, the
663  session is dead as well, clean up */
664  if (NULL != ai->ar)
665  {
666  /* Address expired but not blocked, and thus 'ar' was still
667  live because of the session; deleting just the session
668  will do for an inbound session, but for an outbound we
669  then also need to destroy the address with ATS. */
670  if (GNUNET_NO ==
672  session))
673  {
675  }
676  /* "ar" has been freed, regardless how the branch
677  above played out: it was either freed in
678  #GNUNET_ATS_address_del_session() because it was
679  incoming, or explicitly in
680  #GNUNET_ATS_address_del_session(). */ai->ar = NULL;
681  }
682  destroy_ai (ai);
683  return;
684  }
685 
686  if (NULL == ai->ar)
687  {
688  /* If ATS doesn't know about the address/session, this means
689  this address was blocked. */
690  if (GNUNET_YES ==
693  {
694  /* This was a blocked inbound session, which now lost the
695  session. But inbound addresses are by themselves useless,
696  so we must forget about the address as well. */
697  destroy_ai (ai);
698  return;
699  }
700  /* Otherwise, we are done as we have set `ai->session` to NULL
701  already and ATS will simply not be told about the session when
702  the connection is unblocked and the outbound address becomes
703  available again. . */
704  return;
705  }
706 
707  /* This is the "simple" case where ATS knows about the session and
708  the address is neither blocked nor expired. Delete the session,
709  and if it was inbound, free the address as well. */
710  if (GNUNET_YES ==
712  session))
713  {
714  /* This was an inbound address, the session is now gone, so we
715  need to also forget about the address itself. */
716  ai->ar = NULL;
717  destroy_ai (ai);
718  }
719 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void destroy_ai(struct AddressInfo *ai)
Release memory used by the given address data.
int GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
Check if an address has a local option set.
Definition: address.c:39
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
#define LOG(kind,...)
Log convenience function.
Information we track for each address known to ATS.
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.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
The identity of the host (wraps the signing key of the peer).
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.
void GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
An address got destroyed, stop using it as a valid address.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int expired
Set to GNUNET_YES if the address has expired but we could not yet remove it because we still have a v...
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
addressthe address
distancenew distance value

Definition at line 730 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().

732 {
733  struct AddressInfo *ai;
734 
735  ai = find_ai_no_session (address);
736  if (NULL == ai)
737  {
738  /* We do not know about this address, do nothing. */
739  return;
740  }
742  "Updated distance for peer `%s' to %u\n",
743  GNUNET_i2s (&address->peer),
744  distance);
745  ai->properties.distance = distance;
746  /* Give manipulation its chance to change metrics */
748  ai->session,
749  &ai->properties);
750  /* Address may be blocked, only give ATS if address is
751  currently active. */
752  if (NULL != ai->ar)
754  &ai->properties);
755 }
void GST_manipulation_manipulate_metrics(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_ATS_Properties *prop)
Function that will be called to manipulate ATS information according to current manipulation settings...
struct GNUNET_ATS_Properties properties
Performance properties of this address.
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
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.
#define LOG(kind,...)
Log convenience function.
Information we track for each address known to ATS.
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_ATS_Session * session
Session (can be NULL)
unsigned int distance
Distance on network layer (required for distance-vector routing) in hops.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
addressthe address
delaynew delay value

Definition at line 766 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().

768 {
769  struct AddressInfo *ai;
770 
771  ai = find_ai_no_session (address);
772  if (NULL == ai)
773  {
774  /* We do not know about this address, do nothing. */
775  return;
776  }
778  "Updated latency for peer `%s' to %s\n",
779  GNUNET_i2s (&address->peer),
781  GNUNET_YES));
782  ai->properties.delay = delay;
783  /* Give manipulation its chance to change metrics */
785  ai->session,
786  &ai->properties);
787  /* Address may be blocked, only give ATS if address is
788  currently active. */
789  if (NULL != ai->ar)
791  &ai->properties);
792 }
void GST_manipulation_manipulate_metrics(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_ATS_Properties *prop)
Function that will be called to manipulate ATS information according to current manipulation settings...
struct GNUNET_ATS_Properties properties
Performance properties of this address.
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
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.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
struct GNUNET_TIME_Relative delay
Delay.
#define LOG(kind,...)
Log convenience function.
Information we track for each address known to ATS.
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
addressour information about the address
bps_innew utilization inbound
bps_outnew utilization outbound

Definition at line 804 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().

807 {
808  struct AddressInfo *ai;
809 
810  ai = find_ai_no_session (address);
811  if (NULL == ai)
812  {
813  /* We do not know about this address, do nothing. */
814  return;
815  }
817  "Updating utilization for peer `%s' address %s: %u/%u\n",
818  GNUNET_i2s (&address->peer),
819  GST_plugins_a2s (address),
820  (unsigned int) bps_in,
821  (unsigned int) bps_out);
822  ai->properties.utilization_in = bps_in;
823  ai->properties.utilization_out = bps_out;
824  /* Give manipulation its chance to change metrics */
826  ai->session,
827  &ai->properties);
828  /* Address may be blocked, only give ATS if address is
829  currently active. */
830  if (NULL != ai->ar)
832  &ai->properties);
833 }
void GST_manipulation_manipulate_metrics(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_ATS_Properties *prop)
Function that will be called to manipulate ATS information according to current manipulation settings...
uint32_t utilization_in
Actual traffic on this connection from the other peer to this peer.
struct GNUNET_ATS_Properties properties
Performance properties of this address.
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
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.
#define LOG(kind,...)
Log convenience function.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
Information we track for each address known to ATS.
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
uint32_t utilization_out
Actual traffic on this connection from this peer to the other peer.
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
addressthe address

Definition at line 844 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().

845 {
846  struct AddressInfo *ai;
847 
848  if (0 ==
849  memcmp (&GST_my_identity,
850  &address->peer,
851  sizeof(struct GNUNET_PeerIdentity)))
852  return; /* our own, ignore! */
854  "Address %s of peer %s expired\n",
855  GST_plugins_a2s (address),
856  GNUNET_i2s (&address->peer));
857  ai = find_ai_no_session (address);
858  if (NULL == ai)
859  {
860  GNUNET_assert (0);
861  return;
862  }
863  if (NULL != ai->session)
864  {
865  /* Got an active session, just remember the expiration
866  and act upon it when the session goes down. */
867  ai->expired = GNUNET_YES;
868  return;
869  }
870  /* Address expired, no session, free resources */
871  destroy_ai (ai);
872 }
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void destroy_ai(struct AddressInfo *ai)
Release memory used by the given address data.
#define LOG(kind,...)
Log convenience function.
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
Information we track for each address known to ATS.
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
The identity of the host (wraps the signing key of the peer).
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_ATS_Session * session
Session (can be NULL)
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
int expired
Set to GNUNET_YES if the address has expired but we could not yet remove it because we still have a v...
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 879 of file gnunet-service-transport_ats.c.

References GNUNET_CONTAINER_multipeermap_create(), and GNUNET_YES.

Referenced by run().

880 {
882 }
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsNULL
keywhich peer is this about
valuethe struct AddressInfo
Returns
GNUNET_OK (continue to iterate)

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

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

Referenced by GST_ats_done().

897 {
898  struct AddressInfo *ai = value;
899 
900  destroy_ai (ai);
901  return GNUNET_OK;
902 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void destroy_ai(struct AddressInfo *ai)
Release memory used by the given address data.
static char * value
Value of the record to add/remove.
Information we track for each address known to ATS.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
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 909 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().

910 {
912  &destroy_ai_cb,
913  NULL);
916  p2a = NULL;
917 }
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
static int destroy_ai_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Release memory used by the given address data.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
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.

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