GNUnet  0.19.2
gnunet-service-transport_ats.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2015 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
25 #include "platform.h"
30 #include "gnunet_ats_service.h"
31 
35 #define LOG(kind, ...) GNUNET_log_from (kind, "transport-ats", __VA_ARGS__)
36 
37 
42 {
48 
53 
58 
63 
72 
78 
85 
90  int expired;
91 };
92 
93 
99 
103 static unsigned int num_blocked;
104 
105 
110 {
115 
120 
124  struct AddressInfo *ret;
125 };
126 
127 
133 static void
135 {
137  gettext_noop ("# Addresses given to ATS"),
139  GNUNET_NO);
141  "# blocked addresses",
142  num_blocked,
143  GNUNET_NO);
144 }
145 
146 
157 static int
158 find_ai_cb (void *cls,
159  const struct GNUNET_PeerIdentity *key,
160  void *value)
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 }
175 
176 
185 static struct AddressInfo *
187  struct GNUNET_ATS_Session *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 }
200 
201 
211 static int
213  const struct GNUNET_PeerIdentity *key,
214  void *value)
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 }
230 
231 
239 static struct AddressInfo *
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 }
253 
254 
264 int
266  struct GNUNET_ATS_Session *session)
267 {
268  return (NULL != find_ai (address, session)) ? GNUNET_YES : GNUNET_NO;
269 }
270 
271 
279 int
281 {
282  return (NULL != find_ai_no_session (address))
283  ? GNUNET_YES
284  : GNUNET_NO;
285 }
286 
287 
294 static void
295 unblock_address (void *cls)
296 {
297  struct AddressInfo *ai = cls;
298 
299  ai->unblock_task = NULL;
301  "Unblocking address %s of peer %s\n",
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 }
312 
313 
323 void
325  struct GNUNET_ATS_Session *session)
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  }
342  ai->back_off = GNUNET_TIME_STD_BACKOFF (ai->back_off);
343  if (GNUNET_YES ==
347  "Removing address %s of peer %s from use (inbound died)\n",
349  GNUNET_i2s (&address->peer));
350  else
352  "Blocking address %s of peer %s from use for %s\n",
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 */
372  ai->blocked = GNUNET_TIME_relative_to_absolute (ai->back_off);
373  ai->unblock_task = GNUNET_SCHEDULER_add_delayed (ai->back_off,
375  ai);
376  num_blocked++;
378 }
379 
380 
389 void
391  struct GNUNET_ATS_Session *session)
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);
408  ai->back_off = GNUNET_TIME_UNIT_ZERO;
409 }
410 
411 
422 void
424  struct GNUNET_ATS_Session *session,
425  const struct GNUNET_ATS_Properties *prop)
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),
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);
469  ai->session = session;
470  ai->properties = *prop;
471  ai->ar = ar;
473  &ai->address->peer,
474  ai,
477 }
478 
479 
480 void
482  const struct GNUNET_ATS_Properties *prop)
483 {
484  struct GNUNET_ATS_AddressRecord *ar;
485  struct AddressInfo *ai;
486 
487  if (0 ==
488  memcmp (&GST_my_identity,
489  &address->peer,
490  sizeof(struct GNUNET_PeerIdentity)))
491  return; /* our own, ignore! */
492  /* validadte address */
493  if (NULL == address->transport_name)
494  {
495  GNUNET_break (0);
496  return;
497  }
502  GNUNET_assert (NULL == ai);
504 
505  /* address seems sane, let's tell ATS */
507  "Notifying ATS about peer %s's new address `%s'\n",
508  GNUNET_i2s (&address->peer),
511  address,
512  NULL,
513  prop);
514  GNUNET_assert (NULL != ar);
515  ai = GNUNET_new (struct AddressInfo);
517  ai->ar = ar;
518  ai->properties = *prop;
520  &ai->address->peer,
521  ai,
524 }
525 
526 
536 void
538  struct GNUNET_ATS_Session *session)
539 {
540  struct AddressInfo *ai;
541 
542  if (0 ==
543  memcmp (&GST_my_identity,
544  &address->peer,
545  sizeof(struct GNUNET_PeerIdentity)))
546  return; /* our own, ignore! */
547  ai = find_ai (address, NULL);
548  if (NULL == ai)
549  {
550  /* We may simply already be aware of the session, even if some
551  other part of the code could not tell if it just created a new
552  session or just got one recycled from the plugin; hence, we may
553  be called with "new" session even for an "old" session; in that
554  case, check that this is the case, but just ignore it. */GNUNET_assert (NULL != (find_ai (address, session)));
555  return;
556  }
557  GNUNET_assert (NULL == ai->session);
558  ai->session = session;
560  "Telling ATS about new session for peer %s\n",
561  GNUNET_i2s (&address->peer));
562  /* Note that the address might currently be blocked; we only
563  tell ATS about the session if the address is currently not
564  blocked; otherwise, ATS will be told about the session on
565  unblock. */
566  if (NULL != ai->ar)
568  session);
569  else
570  GNUNET_assert (NULL != ai->unblock_task);
571 }
572 
573 
579 static void
581 {
582  GNUNET_assert (NULL == ai->session);
583  if (NULL != ai->unblock_task)
584  {
585  GNUNET_SCHEDULER_cancel (ai->unblock_task);
586  ai->unblock_task = NULL;
587  num_blocked--;
588  }
591  &ai->address->peer,
592  ai));
594  "Telling ATS to destroy address from peer %s\n",
595  GNUNET_i2s (&ai->address->peer));
596  if (NULL != ai->ar)
597  {
599  ai->ar = NULL;
600  }
603  GNUNET_free (ai);
604 }
605 
606 
618 void
620  struct GNUNET_ATS_Session *session)
621 {
622  struct AddressInfo *ai;
623 
624  if (0 ==
625  memcmp (&GST_my_identity,
626  &address->peer,
627  sizeof(struct GNUNET_PeerIdentity)))
628  return; /* our own, ignore! */
629  if (NULL == session)
630  {
631  GNUNET_break (0);
632  return;
633  }
634  ai = find_ai (address,
635  session);
636  if (NULL == ai)
637  {
638  /* We sometimes create sessions just for sending a PING,
639  and if those are destroyed they were never known to
640  ATS which means we end up here (however, in this
641  case, the address must be an outbound address). */
645  return;
646  }
647  GNUNET_assert (session == ai->session);
648  ai->session = NULL;
650  "Telling ATS to destroy session %p from peer %s\n",
651  session,
652  GNUNET_i2s (&address->peer));
653  if (GNUNET_YES == ai->expired)
654  {
655  /* last reason to keep this 'ai' around is now gone, the
656  session is dead as well, clean up */
657  if (NULL != ai->ar)
658  {
659  /* Address expired but not blocked, and thus 'ar' was still
660  live because of the session; deleting just the session
661  will do for an inbound session, but for an outbound we
662  then also need to destroy the address with ATS. */
663  if (GNUNET_NO ==
665  session))
666  {
668  }
669  /* "ar" has been freed, regardless how the branch
670  above played out: it was either freed in
671  #GNUNET_ATS_address_del_session() because it was
672  incoming, or explicitly in
673  #GNUNET_ATS_address_del_session(). */ai->ar = NULL;
674  }
675  destroy_ai (ai);
676  return;
677  }
678 
679  if (NULL == ai->ar)
680  {
681  /* If ATS doesn't know about the address/session, this means
682  this address was blocked. */
683  if (GNUNET_YES ==
686  {
687  /* This was a blocked inbound session, which now lost the
688  session. But inbound addresses are by themselves useless,
689  so we must forget about the address as well. */
690  destroy_ai (ai);
691  return;
692  }
693  /* Otherwise, we are done as we have set `ai->session` to NULL
694  already and ATS will simply not be told about the session when
695  the connection is unblocked and the outbound address becomes
696  available again. . */
697  return;
698  }
699 
700  /* This is the "simple" case where ATS knows about the session and
701  the address is neither blocked nor expired. Delete the session,
702  and if it was inbound, free the address as well. */
703  if (GNUNET_YES ==
705  session))
706  {
707  /* This was an inbound address, the session is now gone, so we
708  need to also forget about the address itself. */
709  ai->ar = NULL;
710  destroy_ai (ai);
711  }
712 }
713 
714 
722 void
724  uint32_t distance)
725 {
726  struct AddressInfo *ai;
727 
729  if (NULL == ai)
730  {
731  /* We do not know about this address, do nothing. */
732  return;
733  }
735  "Updated distance for peer `%s' to %u\n",
736  GNUNET_i2s (&address->peer),
737  distance);
738  ai->properties.distance = distance;
739  /* Give manipulation its chance to change metrics */
741  ai->session,
742  &ai->properties);
743  /* Address may be blocked, only give ATS if address is
744  currently active. */
745  if (NULL != ai->ar)
747  &ai->properties);
748 }
749 
750 
751 void
754 {
755  struct AddressInfo *ai;
756 
758  if (NULL == ai)
759  {
760  /* We do not know about this address, do nothing. */
761  return;
762  }
764  "Updated latency for peer `%s' to %s\n",
765  GNUNET_i2s (&address->peer),
767  GNUNET_YES));
768  ai->properties.delay = delay;
769  /* Give manipulation its chance to change metrics */
771  ai->session,
772  &ai->properties);
773  /* Address may be blocked, only give ATS if address is
774  currently active. */
775  if (NULL != ai->ar)
777  &ai->properties);
778 }
779 
780 
789 void
791  uint32_t bps_in,
792  uint32_t bps_out)
793 {
794  struct AddressInfo *ai;
795 
797  if (NULL == ai)
798  {
799  /* We do not know about this address, do nothing. */
800  return;
801  }
803  "Updating utilization for peer `%s' address %s: %u/%u\n",
804  GNUNET_i2s (&address->peer),
806  (unsigned int) bps_in,
807  (unsigned int) bps_out);
808  ai->properties.utilization_in = bps_in;
809  ai->properties.utilization_out = bps_out;
810  /* Give manipulation its chance to change metrics */
812  ai->session,
813  &ai->properties);
814  /* Address may be blocked, only give ATS if address is
815  currently active. */
816  if (NULL != ai->ar)
818  &ai->properties);
819 }
820 
821 
829 void
831 {
832  struct AddressInfo *ai;
833 
834  if (0 ==
835  memcmp (&GST_my_identity,
836  &address->peer,
837  sizeof(struct GNUNET_PeerIdentity)))
838  return; /* our own, ignore! */
840  "Address %s of peer %s expired\n",
842  GNUNET_i2s (&address->peer));
844  if (NULL == ai)
845  {
846  GNUNET_assert (0);
847  return;
848  }
849  if (NULL != ai->session)
850  {
851  /* Got an active session, just remember the expiration
852  and act upon it when the session goes down. */
853  ai->expired = GNUNET_YES;
854  return;
855  }
856  /* Address expired, no session, free resources */
857  destroy_ai (ai);
858 }
859 
860 
864 void
866 {
868 }
869 
870 
879 static int
880 destroy_ai_cb (void *cls,
881  const struct GNUNET_PeerIdentity *key,
882  void *value)
883 {
884  struct AddressInfo *ai = value;
885 
886  destroy_ai (ai);
887  return GNUNET_OK;
888 }
889 
890 
894 void
896 {
898  &destroy_ai_cb,
899  NULL);
902  p2a = NULL;
903 }
904 
905 
906 /* end of gnunet-service-transport_ats.c */
#define gettext_noop(String)
Definition: gettext.h:70
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static char * address
GNS address for this phone.
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct GNUNET_ATS_SchedulingHandle * GST_ats
ATS scheduling handle.
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.
static struct GNUNET_CONTAINER_MultiPeerMap * p2a
Map from peer identities to one or more struct AddressInfo values for the peer.
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.
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.
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.
void GST_ats_init()
Initialize ATS subsystem.
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.
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.
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.
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 int destroy_ai_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Release memory used by the given address data.
void GST_ats_block_reset(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Reset address blocking time.
static unsigned int num_blocked
Number of blocked addresses.
int GST_ats_is_known_no_session(const struct GNUNET_HELLO_Address *address)
Test if ATS knows about this address.
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
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.
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 int find_ai_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find matching address info.
static void destroy_ai(struct AddressInfo *ai)
Release memory used by the given address data.
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.
void GST_ats_done()
Shutdown ATS subsystem.
static void unblock_address(void *cls)
The blocking time for an address has expired, allow ATS to suggest it again.
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.
#define LOG(kind,...)
Log convenience function.
void GST_ats_update_distance(const struct GNUNET_HELLO_Address *address, uint32_t distance)
Notify ATS about DV distance change to an address.
interfacing between transport and ATS service
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...
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
Automatic transport selection and outbound bandwidth determination.
void GNUNET_ATS_address_add_session(struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
An address was used to initiate a session.
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.
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.
void GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
An address got destroyed, stop using it as a valid address.
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.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
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).
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.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#define GNUNET_HELLO_address_free(addr)
Free an address.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:99
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
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:112
@ GNUNET_HELLO_ADDRESS_INFO_INBOUND
This is an inbound address and cannot be used to initiate an outbound connection to another peer.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
const char * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:38
@ GNUNET_NT_UNSPECIFIED
Category of last resort.
Definition: gnunet_nt_lib.h:43
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:944
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:1241
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
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:316
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
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:569
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Information we track for each address known to ATS.
int expired
Set to GNUNET_YES if the address has expired but we could not yet remove it because we still have a v...
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
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.
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_ATS_Session * session
Session (can be NULL)
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...
struct GNUNET_HELLO_Address * address
The address (with peer identity).
Closure for find_ai_cb() and find_ai_no_session_cb().
struct GNUNET_ATS_Session * session
Session to look for (only used if the address is inbound).
struct AddressInfo * ret
Where to store the result.
const struct GNUNET_HELLO_Address * address
Address to look for.
Information we track per address, incoming or outgoing.
ATS performance characteristics for an address.
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change.
Session handle for connections.
Internal representation of the hash map.
An address for communicating with a peer.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.