GNUnet  0.10.x
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 
41 struct AddressInfo {
47 
52 
57 
62 
71 
77 
84 
89  int expired;
90 };
91 
92 
98 
102 static unsigned int num_blocked;
103 
104 
108 struct FindClosure {
113 
118 
122  struct AddressInfo *ret;
123 };
124 
125 
131 static void
133 {
135  gettext_noop("# Addresses given to ATS"),
137  GNUNET_NO);
139  "# blocked addresses",
140  num_blocked,
141  GNUNET_NO);
142 }
143 
144 
155 static int
156 find_ai_cb(void *cls,
157  const struct GNUNET_PeerIdentity *key,
158  void *value)
159 {
160  struct FindClosure *fc = cls;
161  struct AddressInfo *ai = value;
162 
163  if ((0 ==
165  ai->address)) &&
166  (fc->session == ai->session))
167  {
168  fc->ret = ai;
169  return GNUNET_NO;
170  }
171  return GNUNET_YES;
172 }
173 
174 
183 static struct AddressInfo *
185  struct GNUNET_ATS_Session *session)
186 {
187  struct FindClosure fc;
188 
189  fc.address = address;
190  fc.session = session;
191  fc.ret = NULL;
193  &address->peer,
194  &find_ai_cb,
195  &fc);
196  return fc.ret;
197 }
198 
199 
209 static int
211  const struct GNUNET_PeerIdentity *key,
212  void *value)
213 {
214  struct FindClosure *fc = cls;
215  struct AddressInfo *ai = value;
216 
217  if (ai->expired)
218  return GNUNET_YES; /* expired do not count here */
219  if (0 ==
221  ai->address))
222  {
223  fc->ret = ai;
224  return GNUNET_NO;
225  }
226  return GNUNET_YES;
227 }
228 
229 
237 static struct AddressInfo *
239 {
240  struct FindClosure fc;
241 
242  fc.address = address;
243  fc.session = NULL;
244  fc.ret = NULL;
246  &address->peer,
248  &fc);
249  return fc.ret;
250 }
251 
252 
262 int
264  struct GNUNET_ATS_Session *session)
265 {
266  return (NULL != find_ai(address, session)) ? GNUNET_YES : GNUNET_NO;
267 }
268 
269 
277 int
279 {
280  return (NULL != find_ai_no_session(address))
281  ? GNUNET_YES
282  : GNUNET_NO;
283 }
284 
285 
292 static void
293 unblock_address(void *cls)
294 {
295  struct AddressInfo *ai = cls;
296 
297  ai->unblock_task = NULL;
299  "Unblocking address %s of peer %s\n",
301  GNUNET_i2s(&ai->address->peer));
303  ai->address,
304  ai->session,
305  &ai->properties);
306  GNUNET_break(NULL != ai->ar);
307  num_blocked--;
309 }
310 
311 
321 void
323  struct GNUNET_ATS_Session *session)
324 {
325  struct AddressInfo *ai;
326 
327  if (0 ==
328  memcmp(&GST_my_identity,
329  &address->peer,
330  sizeof(struct GNUNET_PeerIdentity)))
331  return; /* our own, ignore! */
332  ai = find_ai(address,
333  session);
334  if (NULL == ai || NULL == ai->ar)
335  {
336  /* The address is already gone/blocked, this can happen during a blacklist
337  * callback. */
338  return;
339  }
341  if (GNUNET_YES ==
345  "Removing address %s of peer %s from use (inbound died)\n",
346  GST_plugins_a2s(address),
347  GNUNET_i2s(&address->peer));
348  else
350  "Blocking address %s of peer %s from use for %s\n",
351  GST_plugins_a2s(address),
352  GNUNET_i2s(&address->peer),
354  GNUNET_YES));
355  /* destroy session and address */
356  if ((NULL == session) ||
357  (GNUNET_NO ==
359  session)))
360  {
362  }
363  /* "ar" has been freed, regardless how the branch
364  above played out: it was either freed in
365  #GNUNET_ATS_address_del_session() because it was
366  incoming, or explicitly in
367  #GNUNET_ATS_address_del_session(). */
368  ai->ar = NULL;
369 
370  /* determine when the address should come back to life */
374  ai);
375  num_blocked++;
377 }
378 
379 
388 void
390  struct GNUNET_ATS_Session *session)
391 {
392  struct AddressInfo *ai;
393 
394  if (0 ==
395  memcmp(&GST_my_identity,
396  &address->peer,
397  sizeof(struct GNUNET_PeerIdentity)))
398  return; /* our own, ignore! */
399  ai = find_ai(address, session);
400  if (NULL == ai)
401  {
402  GNUNET_break(0);
403  return;
404  }
405  /* address is in successful use, so it should not be blocked right now */
406  GNUNET_break(NULL == ai->unblock_task);
408 }
409 
410 
421 void
423  struct GNUNET_ATS_Session *session,
424  const struct GNUNET_ATS_Properties *prop)
425 {
427  struct AddressInfo *ai;
428 
429  if (0 ==
430  memcmp(&GST_my_identity,
431  &address->peer,
432  sizeof(struct GNUNET_PeerIdentity)))
433  return; /* our own, ignore! */
434 
435  /* Sanity checks for a valid inbound address */
436  if (NULL == address->transport_name)
437  {
438  GNUNET_break(0);
439  return;
440  }
445  GNUNET_assert(NULL != session);
446  ai = find_ai(address, session);
447  if (NULL != ai)
448  {
449  /* This should only be called for new sessions, and thus
450  we should not already have the address */
451  GNUNET_break(0);
452  return;
453  }
454  /* Is indeed new, let's tell ATS */
456  "Notifying ATS about peer `%s''s new inbound address `%s' session %p in network %s\n",
457  GNUNET_i2s(&address->peer),
458  GST_plugins_a2s(address),
459  session,
460  GNUNET_NT_to_string(prop->scope));
462  address,
463  session,
464  prop);
465  GNUNET_assert(NULL != ar);
466  ai = GNUNET_new(struct AddressInfo);
467  ai->address = GNUNET_HELLO_address_copy(address);
468  ai->session = session;
469  ai->properties = *prop;
470  ai->ar = ar;
472  &ai->address->peer,
473  ai,
476 }
477 
478 
486 void
488  const struct GNUNET_ATS_Properties *prop)
489 {
491  struct AddressInfo *ai;
492 
493  if (0 ==
494  memcmp(&GST_my_identity,
495  &address->peer,
496  sizeof(struct GNUNET_PeerIdentity)))
497  return; /* our own, ignore! */
498  /* validadte address */
499  if (NULL == address->transport_name)
500  {
501  GNUNET_break(0);
502  return;
503  }
507  ai = find_ai_no_session(address);
508  GNUNET_assert(NULL == ai);
510 
511  /* address seems sane, let's tell ATS */
513  "Notifying ATS about peer %s's new address `%s'\n",
514  GNUNET_i2s(&address->peer),
515  GST_plugins_a2s(address));
517  address,
518  NULL,
519  prop);
520  GNUNET_assert(NULL != ar);
521  ai = GNUNET_new(struct AddressInfo);
522  ai->address = GNUNET_HELLO_address_copy(address);
523  ai->ar = ar;
524  ai->properties = *prop;
526  &ai->address->peer,
527  ai,
530 }
531 
532 
542 void
544  struct GNUNET_ATS_Session *session)
545 {
546  struct AddressInfo *ai;
547 
548  if (0 ==
549  memcmp(&GST_my_identity,
550  &address->peer,
551  sizeof(struct GNUNET_PeerIdentity)))
552  return; /* our own, ignore! */
553  ai = find_ai(address, NULL);
554  if (NULL == ai)
555  {
556  /* We may simply already be aware of the session, even if some
557  other part of the code could not tell if it just created a new
558  session or just got one recycled from the plugin; hence, we may
559  be called with "new" session even for an "old" session; in that
560  case, check that this is the case, but just ignore it. */
561  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 }
579 
580 
586 static void
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 }
612 
613 
625 void
627  struct GNUNET_ATS_Session *session)
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(). */
681  ai->ar = NULL;
682  }
683  destroy_ai(ai);
684  return;
685  }
686 
687  if (NULL == ai->ar)
688  {
689  /* If ATS doesn't know about the address/session, this means
690  this address was blocked. */
691  if (GNUNET_YES ==
694  {
695  /* This was a blocked inbound session, which now lost the
696  session. But inbound addresses are by themselves useless,
697  so we must forget about the address as well. */
698  destroy_ai(ai);
699  return;
700  }
701  /* Otherwise, we are done as we have set `ai->session` to NULL
702  already and ATS will simply not be told about the session when
703  the connection is unblocked and the outbound address becomes
704  available again. . */
705  return;
706  }
707 
708  /* This is the "simple" case where ATS knows about the session and
709  the address is neither blocked nor expired. Delete the session,
710  and if it was inbound, free the address as well. */
711  if (GNUNET_YES ==
713  session))
714  {
715  /* This was an inbound address, the session is now gone, so we
716  need to also forget about the address itself. */
717  ai->ar = NULL;
718  destroy_ai(ai);
719  }
720 }
721 
722 
730 void
732  uint32_t distance)
733 {
734  struct AddressInfo *ai;
735 
736  ai = find_ai_no_session(address);
737  if (NULL == ai)
738  {
739  /* We do not know about this address, do nothing. */
740  return;
741  }
743  "Updated distance for peer `%s' to %u\n",
744  GNUNET_i2s(&address->peer),
745  distance);
746  ai->properties.distance = distance;
747  /* Give manipulation its chance to change metrics */
749  ai->session,
750  &ai->properties);
751  /* Address may be blocked, only give ATS if address is
752  currently active. */
753  if (NULL != ai->ar)
755  &ai->properties);
756 }
757 
758 
766 void
769 {
770  struct AddressInfo *ai;
771 
772  ai = find_ai_no_session(address);
773  if (NULL == ai)
774  {
775  /* We do not know about this address, do nothing. */
776  return;
777  }
779  "Updated latency for peer `%s' to %s\n",
780  GNUNET_i2s(&address->peer),
782  GNUNET_YES));
783  ai->properties.delay = delay;
784  /* Give manipulation its chance to change metrics */
786  ai->session,
787  &ai->properties);
788  /* Address may be blocked, only give ATS if address is
789  currently active. */
790  if (NULL != ai->ar)
792  &ai->properties);
793 }
794 
795 
804 void
806  uint32_t bps_in,
807  uint32_t bps_out)
808 {
809  struct AddressInfo *ai;
810 
811  ai = find_ai_no_session(address);
812  if (NULL == ai)
813  {
814  /* We do not know about this address, do nothing. */
815  return;
816  }
818  "Updating utilization for peer `%s' address %s: %u/%u\n",
819  GNUNET_i2s(&address->peer),
820  GST_plugins_a2s(address),
821  (unsigned int)bps_in,
822  (unsigned int)bps_out);
823  ai->properties.utilization_in = bps_in;
824  ai->properties.utilization_out = bps_out;
825  /* Give manipulation its chance to change metrics */
827  ai->session,
828  &ai->properties);
829  /* Address may be blocked, only give ATS if address is
830  currently active. */
831  if (NULL != ai->ar)
833  &ai->properties);
834 }
835 
836 
844 void
846 {
847  struct AddressInfo *ai;
848 
849  if (0 ==
850  memcmp(&GST_my_identity,
851  &address->peer,
852  sizeof(struct GNUNET_PeerIdentity)))
853  return; /* our own, ignore! */
855  "Address %s of peer %s expired\n",
856  GST_plugins_a2s(address),
857  GNUNET_i2s(&address->peer));
858  ai = find_ai_no_session(address);
859  if (NULL == ai)
860  {
861  GNUNET_assert(0);
862  return;
863  }
864  if (NULL != ai->session)
865  {
866  /* Got an active session, just remember the expiration
867  and act upon it when the session goes down. */
868  ai->expired = GNUNET_YES;
869  return;
870  }
871  /* Address expired, no session, free resources */
872  destroy_ai(ai);
873 }
874 
875 
879 void
881 {
883 }
884 
885 
894 static int
895 destroy_ai_cb(void *cls,
896  const struct GNUNET_PeerIdentity *key,
897  void *value)
898 {
899  struct AddressInfo *ai = value;
900 
901  destroy_ai(ai);
902  return GNUNET_OK;
903 }
904 
905 
909 void
911 {
913  &destroy_ai_cb,
914  NULL);
917  p2a = NULL;
918 }
919 
920 /* end of gnunet-service-transport_ats.c */
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
struct GNUNET_ATS_Session * session
Session to look for (only used if the address is inbound).
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 * GNUNET_NT_to_string(enum GNUNET_NetworkType net)
Convert a enum GNUNET_NetworkType to a string.
Definition: nt.c:43
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.
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...
void GST_ats_done()
Shutdown ATS subsystem.
uint32_t utilization_in
Actual traffic on this connection from the other peer to this peer.
Closure for find_ai_cb() and find_ai_no_session_cb().
void GST_ats_update_distance(const struct GNUNET_HELLO_Address *address, uint32_t distance)
Notify ATS about DV distance change to an address.
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
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct AddressInfo * ret
Where to store the result.
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...
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.
struct GNUNET_ATS_Properties properties
Performance properties of this address.
static unsigned int num_blocked
Number of blocked addresses.
interfacing between transport and ATS service
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_ATS_SchedulingHandle * GST_ats
ATS scheduling handle.
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).
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.
ATS performance characteristics for an address.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
static void destroy_ai(struct AddressInfo *ai)
Release memory used by the given address data.
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
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
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:1237
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct GNUNET_ATS_AddressRecord * ar
Record with ATS API for the address.
static char * value
Value of the record to add/remove.
Information about ongoing sessions of the transport client.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
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.
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:686
const char * transport_name
Name of the transport plugin enabling the communication using this address.
struct GNUNET_TIME_Relative delay
Delay.
#define LOG(kind,...)
Log convenience function.
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.
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.
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.
Internal representation of the hash map.
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_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.
int GST_ats_is_known_no_session(const struct GNUNET_HELLO_Address *address)
Test if ATS knows about this address.
static int destroy_ai_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Release memory used by the given address data.
static struct AddressInfo * find_ai_no_session(const struct GNUNET_HELLO_Address *address)
Find the address information struct for the given address (ignoring sessions)
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.
struct GNUNET_HashCode key
The key used in the DHT.
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.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
#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?
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
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.
const struct GNUNET_HELLO_Address * address
Address to look for.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
The identity of the host (wraps the signing key of the peer).
void GST_ats_block_reset(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Reset address blocking time.
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.
An address for communicating with a peer.
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.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
Automatic transport selection and outbound bandwidth determination.
Entry in list of pending tasks.
Definition: scheduler.c:131
void GNUNET_ATS_address_destroy(struct GNUNET_ATS_AddressRecord *ar)
An address got destroyed, stop using it as a valid 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.
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...
struct GNUNET_HELLO_Address * address
The address (with peer identity).
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GNUNET_ATS_address_add_session(struct GNUNET_ATS_AddressRecord *ar, struct GNUNET_ATS_Session *session)
An address was used to initiate a session.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_ATS_Session * session
Session (can be NULL)
static int find_ai_cb(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Find matching address info.
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).
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.
#define GNUNET_HELLO_address_free(addr)
Free an address.
int expired
Set to GNUNET_YES if the address has expired but we could not yet remove it because we still have a v...
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.
static void publish_p2a_stat_update()
Provide an update on the p2a map size to statistics.
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.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
uint32_t utilization_out
Actual traffic on this connection from this peer to the other peer.
#define gettext_noop(String)
Definition: gettext.h:69
Category of last resort.
Definition: gnunet_nt_lib.h:39
void GST_ats_init()
Initialize ATS subsystem.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956