2 This file is part of GNUnet.
3 Copyright (C) 2015 GNUnet e.V.
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.
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.
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/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
21 * @file transport/gnunet-service-transport_ats.c
22 * @brief interfacing between transport and ATS service
23 * @author Christian Grothoff
26 #include "gnunet-service-transport.h"
27 #include "gnunet-service-transport_ats.h"
28 #include "gnunet-service-transport_manipulation.h"
29 #include "gnunet-service-transport_plugins.h"
30 #include "gnunet_ats_service.h"
33 * Log convenience function.
35 #define LOG(kind,...) GNUNET_log_from(kind, "transport-ats", __VA_ARGS__)
39 * Information we track for each address known to ATS.
45 * The address (with peer identity). Must never change
46 * while this struct is in the #p2a map.
48 struct GNUNET_HELLO_Address *address;
51 * Session (can be NULL)
53 struct GNUNET_ATS_Session *session;
56 * Record with ATS API for the address.
58 struct GNUNET_ATS_AddressRecord *ar;
61 * Performance properties of this address.
63 struct GNUNET_ATS_Properties properties;
66 * Time until when this address is blocked and should thus not be
67 * made available to ATS (@e ar should be NULL until this time).
68 * Used when transport determines that for some reason it
69 * (temporarily) cannot use an address, even though it has been
72 struct GNUNET_TIME_Absolute blocked;
75 * If an address is blocked as part of an exponential back-off,
76 * we track the current size of the backoff here.
78 struct GNUNET_TIME_Relative back_off;
81 * Task scheduled to unblock an ATS-blocked address at
82 * @e blocked time, or NULL if the address is not blocked
83 * (and thus @e ar is non-NULL).
85 struct GNUNET_SCHEDULER_Task *unblock_task;
88 * Set to #GNUNET_YES if the address has expired but we could
89 * not yet remove it because we still have a valid session.
97 * Map from peer identities to one or more `struct AddressInfo` values
100 static struct GNUNET_CONTAINER_MultiPeerMap *p2a;
103 * Number of blocked addresses.
105 static unsigned int num_blocked;
109 * Closure for #find_ai_cb() and #find_ai_no_session_cb().
115 * Session to look for (only used if the address is inbound).
117 struct GNUNET_ATS_Session *session;
120 * Address to look for.
122 const struct GNUNET_HELLO_Address *address;
125 * Where to store the result.
127 struct AddressInfo *ret;
133 * Provide an update on the `p2a` map size to statistics.
134 * This function should be called whenever the `p2a` map
138 publish_p2a_stat_update ()
140 GNUNET_STATISTICS_set (GST_stats,
141 gettext_noop ("# Addresses given to ATS"),
142 GNUNET_CONTAINER_multipeermap_size (p2a) - num_blocked,
144 GNUNET_STATISTICS_set (GST_stats,
145 "# blocked addresses",
152 * Find matching address info. Both the address and the session
153 * must match; note that expired addresses are still found (as
154 * the session kind-of keeps those alive).
156 * @param cls the `struct FindClosure`
157 * @param key which peer is this about
158 * @param value the `struct AddressInfo`
159 * @return #GNUNET_YES to continue to iterate, #GNUNET_NO if we found the value
162 find_ai_cb (void *cls,
163 const struct GNUNET_PeerIdentity *key,
166 struct FindClosure *fc = cls;
167 struct AddressInfo *ai = value;
170 GNUNET_HELLO_address_cmp (fc->address,
172 (fc->session == ai->session) )
182 * Find the address information struct for the
183 * given @a address and @a session.
185 * @param address address to look for
186 * @param session session to match for inbound connections
187 * @return NULL if this combination is unknown
189 static struct AddressInfo *
190 find_ai (const struct GNUNET_HELLO_Address *address,
191 struct GNUNET_ATS_Session *session)
193 struct FindClosure fc;
195 fc.address = address;
196 fc.session = session;
198 GNUNET_CONTAINER_multipeermap_get_multiple (p2a,
207 * Find matching address info, ignoring sessions and expired
210 * @param cls the `struct FindClosure`
211 * @param key which peer is this about
212 * @param value the `struct AddressInfo`
213 * @return #GNUNET_YES to continue to iterate, #GNUNET_NO if we found the value
216 find_ai_no_session_cb (void *cls,
217 const struct GNUNET_PeerIdentity *key,
220 struct FindClosure *fc = cls;
221 struct AddressInfo *ai = value;
224 return GNUNET_YES; /* expired do not count here */
226 GNUNET_HELLO_address_cmp (fc->address,
237 * Find the address information struct for the
238 * given address (ignoring sessions)
240 * @param address address to look for
241 * @return NULL if this combination is unknown
243 static struct AddressInfo *
244 find_ai_no_session (const struct GNUNET_HELLO_Address *address)
246 struct FindClosure fc;
248 fc.address = address;
251 GNUNET_CONTAINER_multipeermap_get_multiple (p2a,
253 &find_ai_no_session_cb,
260 * Test if ATS knows about this @a address and @a session.
261 * Note that even if the address is expired, we return
262 * #GNUNET_YES if the respective session matches.
264 * @param address the address
265 * @param session the session
266 * @return #GNUNET_YES if @a address is known, #GNUNET_NO if not.
269 GST_ats_is_known (const struct GNUNET_HELLO_Address *address,
270 struct GNUNET_ATS_Session *session)
272 return (NULL != find_ai (address, session)) ? GNUNET_YES : GNUNET_NO;
277 * Test if ATS knows about this @a address. Note that
278 * expired addresses do not count.
280 * @param address the address
281 * @return #GNUNET_YES if @a address is known, #GNUNET_NO if not.
284 GST_ats_is_known_no_session (const struct GNUNET_HELLO_Address *address)
286 return (NULL != find_ai_no_session (address))
293 * The blocking time for an address has expired, allow ATS to
296 * @param cls the `struct AddressInfo` of the address to unblock
299 unblock_address (void *cls)
301 struct AddressInfo *ai = cls;
303 ai->unblock_task = NULL;
304 LOG (GNUNET_ERROR_TYPE_DEBUG,
305 "Unblocking address %s of peer %s\n",
306 GST_plugins_a2s (ai->address),
307 GNUNET_i2s (&ai->address->peer));
308 ai->ar = GNUNET_ATS_address_add (GST_ats,
312 GNUNET_break (NULL != ai->ar);
314 publish_p2a_stat_update ();
319 * Temporarily block a valid address for use by ATS for address
320 * suggestions. This function should be called if an address was
321 * suggested by ATS but failed to perform (i.e. failure to establish a
322 * session or to exchange the PING/PONG).
324 * @param address the address to block
325 * @param session the session (can be NULL)
328 GST_ats_block_address (const struct GNUNET_HELLO_Address *address,
329 struct GNUNET_ATS_Session *session)
331 struct AddressInfo *ai;
334 memcmp (&GST_my_identity,
336 sizeof (struct GNUNET_PeerIdentity)))
337 return; /* our own, ignore! */
338 ai = find_ai (address,
340 if (NULL == ai || NULL == ai->ar)
342 /* The address is already gone/blocked, this can happen during a blacklist
346 ai->back_off = GNUNET_TIME_STD_BACKOFF (ai->back_off);
348 GNUNET_HELLO_address_check_option (address,
349 GNUNET_HELLO_ADDRESS_INFO_INBOUND))
350 LOG (GNUNET_ERROR_TYPE_DEBUG,
351 "Removing address %s of peer %s from use (inbound died)\n",
352 GST_plugins_a2s (address),
353 GNUNET_i2s (&address->peer));
355 LOG (GNUNET_ERROR_TYPE_INFO,
356 "Blocking address %s of peer %s from use for %s\n",
357 GST_plugins_a2s (address),
358 GNUNET_i2s (&address->peer),
359 GNUNET_STRINGS_relative_time_to_string (ai->back_off,
361 /* destroy session and address */
362 if ( (NULL == session) ||
364 GNUNET_ATS_address_del_session (ai->ar,
367 GNUNET_ATS_address_destroy (ai->ar);
369 /* "ar" has been freed, regardless how the branch
370 above played out: it was either freed in
371 #GNUNET_ATS_address_del_session() because it was
372 incoming, or explicitly in
373 #GNUNET_ATS_address_del_session(). */
376 /* determine when the address should come back to life */
377 ai->blocked = GNUNET_TIME_relative_to_absolute (ai->back_off);
378 ai->unblock_task = GNUNET_SCHEDULER_add_delayed (ai->back_off,
382 publish_p2a_stat_update ();
387 * Reset address blocking time. Resets the exponential
388 * back-off timer for this address to zero. Called when
389 * an address was used to create a successful connection.
391 * @param address the address to reset the blocking timer
392 * @param session the session (can be NULL)
395 GST_ats_block_reset (const struct GNUNET_HELLO_Address *address,
396 struct GNUNET_ATS_Session *session)
398 struct AddressInfo *ai;
401 memcmp (&GST_my_identity,
403 sizeof (struct GNUNET_PeerIdentity)))
404 return; /* our own, ignore! */
405 ai = find_ai (address, session);
411 /* address is in successful use, so it should not be blocked right now */
412 GNUNET_break (NULL == ai->unblock_task);
413 ai->back_off = GNUNET_TIME_UNIT_ZERO;
418 * Notify ATS about a new inbound @a address. The @a address in
419 * combination with the @a session must be new, but this function will
420 * perform a santiy check. If the @a address is indeed new, make it
423 * @param address the address
424 * @param session the session
425 * @param prop performance information
428 GST_ats_add_inbound_address (const struct GNUNET_HELLO_Address *address,
429 struct GNUNET_ATS_Session *session,
430 const struct GNUNET_ATS_Properties *prop)
432 struct GNUNET_ATS_AddressRecord *ar;
433 struct AddressInfo *ai;
436 memcmp (&GST_my_identity,
438 sizeof (struct GNUNET_PeerIdentity)))
439 return; /* our own, ignore! */
441 /* Sanity checks for a valid inbound address */
442 if (NULL == address->transport_name)
447 GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
448 GNUNET_assert (GNUNET_YES ==
449 GNUNET_HELLO_address_check_option (address,
450 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
451 GNUNET_assert (NULL != session);
452 ai = find_ai (address, session);
455 /* This should only be called for new sessions, and thus
456 we should not already have the address */
460 /* Is indeed new, let's tell ATS */
461 LOG (GNUNET_ERROR_TYPE_DEBUG,
462 "Notifying ATS about peer `%s''s new inbound address `%s' session %p in network %s\n",
463 GNUNET_i2s (&address->peer),
464 GST_plugins_a2s (address),
466 GNUNET_NT_to_string (prop->scope));
467 ar = GNUNET_ATS_address_add (GST_ats,
471 GNUNET_assert (NULL != ar);
472 ai = GNUNET_new (struct AddressInfo);
473 ai->address = GNUNET_HELLO_address_copy (address);
474 ai->session = session;
475 ai->properties = *prop;
477 (void) GNUNET_CONTAINER_multipeermap_put (p2a,
480 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
481 publish_p2a_stat_update ();
486 * Notify ATS about the new address including the network this address is
487 * located in. The address must NOT be inbound and must be new to ATS.
489 * @param address the address
490 * @param prop performance information
493 GST_ats_add_address (const struct GNUNET_HELLO_Address *address,
494 const struct GNUNET_ATS_Properties *prop)
496 struct GNUNET_ATS_AddressRecord *ar;
497 struct AddressInfo *ai;
500 memcmp (&GST_my_identity,
502 sizeof (struct GNUNET_PeerIdentity)))
503 return; /* our own, ignore! */
504 /* validadte address */
505 if (NULL == address->transport_name)
510 GNUNET_assert (GNUNET_YES !=
511 GNUNET_HELLO_address_check_option (address,
512 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
513 ai = find_ai_no_session (address);
514 GNUNET_assert (NULL == ai);
515 GNUNET_break (GNUNET_NT_UNSPECIFIED != prop->scope);
517 /* address seems sane, let's tell ATS */
518 LOG (GNUNET_ERROR_TYPE_INFO,
519 "Notifying ATS about peer %s's new address `%s'\n",
520 GNUNET_i2s (&address->peer),
521 GST_plugins_a2s (address));
522 ar = GNUNET_ATS_address_add (GST_ats,
526 GNUNET_assert (NULL != ar);
527 ai = GNUNET_new (struct AddressInfo);
528 ai->address = GNUNET_HELLO_address_copy (address);
530 ai->properties = *prop;
531 (void) GNUNET_CONTAINER_multipeermap_put (p2a,
534 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
535 publish_p2a_stat_update ();
540 * Notify ATS about a new @a session now existing for the given
541 * @a address. Essentially, an outbound @a address was used
542 * to establish a @a session. It is safe to call this function
543 * repeatedly for the same @a address and @a session pair.
545 * @param address the address
546 * @param session the session
549 GST_ats_new_session (const struct GNUNET_HELLO_Address *address,
550 struct GNUNET_ATS_Session *session)
552 struct AddressInfo *ai;
555 memcmp (&GST_my_identity,
557 sizeof (struct GNUNET_PeerIdentity)))
558 return; /* our own, ignore! */
559 ai = find_ai (address, NULL);
562 /* We may simply already be aware of the session, even if some
563 other part of the code could not tell if it just created a new
564 session or just got one recycled from the plugin; hence, we may
565 be called with "new" session even for an "old" session; in that
566 case, check that this is the case, but just ignore it. */
567 GNUNET_assert (NULL != (find_ai (address, session)));
570 GNUNET_assert (NULL == ai->session);
571 ai->session = session;
572 LOG (GNUNET_ERROR_TYPE_DEBUG,
573 "Telling ATS about new session for peer %s\n",
574 GNUNET_i2s (&address->peer));
575 /* Note that the address might currently be blocked; we only
576 tell ATS about the session if the address is currently not
577 blocked; otherwise, ATS will be told about the session on
580 GNUNET_ATS_address_add_session (ai->ar,
583 GNUNET_assert (NULL != ai->unblock_task);
588 * Release memory used by the given address data.
590 * @param ai the `struct AddressInfo`
593 destroy_ai (struct AddressInfo *ai)
595 GNUNET_assert (NULL == ai->session);
596 if (NULL != ai->unblock_task)
598 GNUNET_SCHEDULER_cancel (ai->unblock_task);
599 ai->unblock_task = NULL;
602 GNUNET_assert (GNUNET_YES ==
603 GNUNET_CONTAINER_multipeermap_remove (p2a,
606 LOG (GNUNET_ERROR_TYPE_DEBUG,
607 "Telling ATS to destroy address from peer %s\n",
608 GNUNET_i2s (&ai->address->peer));
611 GNUNET_ATS_address_destroy (ai->ar);
614 publish_p2a_stat_update ();
615 GNUNET_HELLO_address_free (ai->address);
621 * Notify ATS that the @a session (but not the @a address) of
622 * a given @a address is no longer relevant. (The @a session
623 * went down.) This function may be called even if for the
624 * respective outbound address #GST_ats_new_session() was
625 * never called and thus the pair is unknown to ATS. In this
626 * case, the call is simply ignored.
628 * @param address the address
629 * @param session the session
632 GST_ats_del_session (const struct GNUNET_HELLO_Address *address,
633 struct GNUNET_ATS_Session *session)
635 struct AddressInfo *ai;
638 memcmp (&GST_my_identity,
640 sizeof (struct GNUNET_PeerIdentity)))
641 return; /* our own, ignore! */
647 ai = find_ai (address,
651 /* We sometimes create sessions just for sending a PING,
652 and if those are destroyed they were never known to
653 ATS which means we end up here (however, in this
654 case, the address must be an outbound address). */
655 GNUNET_break (GNUNET_YES !=
656 GNUNET_HELLO_address_check_option (address,
657 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
660 GNUNET_assert (session == ai->session);
662 LOG (GNUNET_ERROR_TYPE_DEBUG,
663 "Telling ATS to destroy session %p from peer %s\n",
665 GNUNET_i2s (&address->peer));
666 if (GNUNET_YES == ai->expired)
668 /* last reason to keep this 'ai' around is now gone, the
669 session is dead as well, clean up */
672 /* Address expired but not blocked, and thus 'ar' was still
673 live because of the session; deleting just the session
674 will do for an inbound session, but for an outbound we
675 then also need to destroy the address with ATS. */
677 GNUNET_ATS_address_del_session (ai->ar,
680 GNUNET_ATS_address_destroy (ai->ar);
682 /* "ar" has been freed, regardless how the branch
683 above played out: it was either freed in
684 #GNUNET_ATS_address_del_session() because it was
685 incoming, or explicitly in
686 #GNUNET_ATS_address_del_session(). */
695 /* If ATS doesn't know about the address/session, this means
696 this address was blocked. */
698 GNUNET_HELLO_address_check_option (address,
699 GNUNET_HELLO_ADDRESS_INFO_INBOUND))
701 /* This was a blocked inbound session, which now lost the
702 session. But inbound addresses are by themselves useless,
703 so we must forget about the address as well. */
707 /* Otherwise, we are done as we have set `ai->session` to NULL
708 already and ATS will simply not be told about the session when
709 the connection is unblocked and the outbound address becomes
710 available again. . */
714 /* This is the "simple" case where ATS knows about the session and
715 the address is neither blocked nor expired. Delete the session,
716 and if it was inbound, free the address as well. */
718 GNUNET_ATS_address_del_session (ai->ar,
721 /* This was an inbound address, the session is now gone, so we
722 need to also forget about the address itself. */
730 * Notify ATS about DV @a distance change to an @a address.
731 * Does nothing if the @a address is not known to us.
733 * @param address the address
734 * @param distance new distance value
737 GST_ats_update_distance (const struct GNUNET_HELLO_Address *address,
740 struct AddressInfo *ai;
742 ai = find_ai_no_session (address);
745 /* We do not know about this address, do nothing. */
748 LOG (GNUNET_ERROR_TYPE_DEBUG,
749 "Updated distance for peer `%s' to %u\n",
750 GNUNET_i2s (&address->peer),
752 ai->properties.distance = distance;
753 /* Give manipulation its chance to change metrics */
754 GST_manipulation_manipulate_metrics (address,
757 /* Address may be blocked, only give ATS if address is
760 GNUNET_ATS_address_update (ai->ar,
766 * Notify ATS about @a delay changes to properties of an @a address.
767 * Does nothing if the @a address is not known to us.
769 * @param address the address
770 * @param delay new delay value
773 GST_ats_update_delay (const struct GNUNET_HELLO_Address *address,
774 struct GNUNET_TIME_Relative delay)
776 struct AddressInfo *ai;
778 ai = find_ai_no_session (address);
781 /* We do not know about this address, do nothing. */
784 LOG (GNUNET_ERROR_TYPE_DEBUG,
785 "Updated latency for peer `%s' to %s\n",
786 GNUNET_i2s (&address->peer),
787 GNUNET_STRINGS_relative_time_to_string (delay,
789 ai->properties.delay = delay;
790 /* Give manipulation its chance to change metrics */
791 GST_manipulation_manipulate_metrics (address,
794 /* Address may be blocked, only give ATS if address is
797 GNUNET_ATS_address_update (ai->ar,
803 * Notify ATS about utilization changes to an @a address.
804 * Does nothing if the @a address is not known to us.
806 * @param address our information about the address
807 * @param bps_in new utilization inbound
808 * @param bps_out new utilization outbound
811 GST_ats_update_utilization (const struct GNUNET_HELLO_Address *address,
815 struct AddressInfo *ai;
817 ai = find_ai_no_session (address);
820 /* We do not know about this address, do nothing. */
823 LOG (GNUNET_ERROR_TYPE_DEBUG,
824 "Updating utilization for peer `%s' address %s: %u/%u\n",
825 GNUNET_i2s (&address->peer),
826 GST_plugins_a2s (address),
827 (unsigned int) bps_in,
828 (unsigned int) bps_out);
829 ai->properties.utilization_in = bps_in;
830 ai->properties.utilization_out = bps_out;
831 /* Give manipulation its chance to change metrics */
832 GST_manipulation_manipulate_metrics (address,
835 /* Address may be blocked, only give ATS if address is
838 GNUNET_ATS_address_update (ai->ar,
844 * Notify ATS that the address has expired and thus cannot
845 * be used any longer. This function must only be called
846 * if the corresponding session is already gone.
848 * @param address the address
851 GST_ats_expire_address (const struct GNUNET_HELLO_Address *address)
853 struct AddressInfo *ai;
856 memcmp (&GST_my_identity,
858 sizeof (struct GNUNET_PeerIdentity)))
859 return; /* our own, ignore! */
860 LOG (GNUNET_ERROR_TYPE_DEBUG,
861 "Address %s of peer %s expired\n",
862 GST_plugins_a2s (address),
863 GNUNET_i2s (&address->peer));
864 ai = find_ai_no_session (address);
870 if (NULL != ai->session)
872 /* Got an active session, just remember the expiration
873 and act upon it when the session goes down. */
874 ai->expired = GNUNET_YES;
877 /* Address expired, no session, free resources */
883 * Initialize ATS subsystem.
888 p2a = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_YES);
893 * Release memory used by the given address data.
896 * @param key which peer is this about
897 * @param value the `struct AddressInfo`
898 * @return #GNUNET_OK (continue to iterate)
901 destroy_ai_cb (void *cls,
902 const struct GNUNET_PeerIdentity *key,
905 struct AddressInfo *ai = value;
913 * Shutdown ATS subsystem.
918 GNUNET_CONTAINER_multipeermap_iterate (p2a,
921 publish_p2a_stat_update ();
922 GNUNET_CONTAINER_multipeermap_destroy (p2a);
926 /* end of gnunet-service-transport_ats.c */