2 This file is part of GNUnet.
3 Copyright (C) 2015 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 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 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, USA.
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 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 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 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 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
300 unblock_address (void *cls,
301 const struct GNUNET_SCHEDULER_TaskContext *tc)
303 struct AddressInfo *ai = cls;
305 ai->unblock_task = NULL;
306 LOG (GNUNET_ERROR_TYPE_DEBUG,
307 "Unblocking address %s of peer %s\n",
308 GST_plugins_a2s (ai->address),
309 GNUNET_i2s (&ai->address->peer));
310 ai->ar = GNUNET_ATS_address_add (GST_ats,
314 GNUNET_break (NULL != ai->ar);
316 publish_p2a_stat_update ();
321 * Temporarily block a valid address for use by ATS for address
322 * suggestions. This function should be called if an address was
323 * suggested by ATS but failed to perform (i.e. failure to establish a
324 * session or to exchange the PING/PONG).
326 * @param address the address to block
327 * @param session the session (can be NULL)
330 GST_ats_block_address (const struct GNUNET_HELLO_Address *address,
331 struct Session *session)
333 struct AddressInfo *ai;
335 ai = find_ai (address,
344 /* already blocked, how did it get used!? */
348 ai->back_off = GNUNET_TIME_STD_BACKOFF (ai->back_off);
350 GNUNET_HELLO_address_check_option (address,
351 GNUNET_HELLO_ADDRESS_INFO_INBOUND))
352 LOG (GNUNET_ERROR_TYPE_DEBUG,
353 "Removing address %s of peer %s from use (inbound died)\n",
354 GST_plugins_a2s (address),
355 GNUNET_i2s (&address->peer));
357 LOG (GNUNET_ERROR_TYPE_INFO,
358 "Blocking address %s of peer %s from use for %s\n",
359 GST_plugins_a2s (address),
360 GNUNET_i2s (&address->peer),
361 GNUNET_STRINGS_relative_time_to_string (ai->back_off,
363 /* destroy session and address */
364 if ( (NULL == session) ||
366 GNUNET_ATS_address_del_session (ai->ar,
369 GNUNET_ATS_address_destroy (ai->ar);
371 /* "ar" has been freed, regardless how the branch
372 above played out: it was either freed in
373 #GNUNET_ATS_address_del_session() because it was
374 incoming, or explicitly in
375 #GNUNET_ATS_address_del_session(). */
378 /* determine when the address should come back to life */
379 ai->blocked = GNUNET_TIME_relative_to_absolute (ai->back_off);
380 ai->unblock_task = GNUNET_SCHEDULER_add_delayed (ai->back_off,
384 publish_p2a_stat_update ();
389 * Reset address blocking time. Resets the exponential
390 * back-off timer for this address to zero. Called when
391 * an address was used to create a successful connection.
393 * @param address the address to reset the blocking timer
394 * @param session the session (can be NULL)
397 GST_ats_block_reset (const struct GNUNET_HELLO_Address *address,
398 struct Session *session)
400 struct AddressInfo *ai;
402 ai = find_ai (address, session);
408 /* address is in successful use, so it should not be blocked right now */
409 GNUNET_break (NULL == ai->unblock_task);
410 ai->back_off = GNUNET_TIME_UNIT_ZERO;
415 * Notify ATS about a new inbound @a address. The @a address in
416 * combination with the @a session must be new, but this function will
417 * perform a santiy check. If the @a address is indeed new, make it
420 * @param address the address
421 * @param session the session
422 * @param prop performance information
425 GST_ats_add_inbound_address (const struct GNUNET_HELLO_Address *address,
426 struct Session *session,
427 const struct GNUNET_ATS_Properties *prop)
429 struct GNUNET_ATS_AddressRecord *ar;
430 struct AddressInfo *ai;
432 /* Sanity checks for a valid inbound address */
433 if (NULL == address->transport_name)
438 GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != prop->scope);
439 GNUNET_assert (GNUNET_YES ==
440 GNUNET_HELLO_address_check_option (address,
441 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
442 GNUNET_assert (NULL != session);
443 ai = find_ai (address, session);
446 /* This should only be called for new sessions, and thus
447 we should not already have the address */
451 /* Is indeed new, let's tell ATS */
452 LOG (GNUNET_ERROR_TYPE_DEBUG,
453 "Notifying ATS about peer `%s''s new inbound address `%s' session %p in network %s\n",
454 GNUNET_i2s (&address->peer),
455 GST_plugins_a2s (address),
457 GNUNET_ATS_print_network_type (prop->scope));
458 ar = GNUNET_ATS_address_add (GST_ats,
462 GNUNET_assert (NULL != ar);
463 ai = GNUNET_new (struct AddressInfo);
464 ai->address = GNUNET_HELLO_address_copy (address);
465 ai->session = session;
466 ai->properties = *prop;
468 (void) GNUNET_CONTAINER_multipeermap_put (p2a,
471 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
472 publish_p2a_stat_update ();
477 * Notify ATS about the new address including the network this address is
478 * located in. The address must NOT be inbound and must be new to ATS.
480 * @param address the address
481 * @param prop performance information
484 GST_ats_add_address (const struct GNUNET_HELLO_Address *address,
485 const struct GNUNET_ATS_Properties *prop)
487 struct GNUNET_ATS_AddressRecord *ar;
488 struct AddressInfo *ai;
490 /* validadte address */
491 if (NULL == address->transport_name)
496 GNUNET_assert (GNUNET_YES !=
497 GNUNET_HELLO_address_check_option (address,
498 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
499 ai = find_ai_no_session (address);
500 GNUNET_assert (NULL == ai);
501 GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != prop->scope);
503 /* address seems sane, let's tell ATS */
504 LOG (GNUNET_ERROR_TYPE_INFO,
505 "Notifying ATS about peer %s's new address `%s'\n",
506 GNUNET_i2s (&address->peer),
507 GST_plugins_a2s (address));
508 ar = GNUNET_ATS_address_add (GST_ats,
512 GNUNET_assert (NULL != ar);
513 ai = GNUNET_new (struct AddressInfo);
514 ai->address = GNUNET_HELLO_address_copy (address);
516 ai->properties = *prop;
517 (void) GNUNET_CONTAINER_multipeermap_put (p2a,
520 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
521 publish_p2a_stat_update ();
526 * Notify ATS about a new @a session now existing for the given
527 * @a address. Essentially, an outbound @a address was used
528 * to establish a @a session. It is safe to call this function
529 * repeatedly for the same @a address and @a session pair.
531 * @param address the address
532 * @param session the session
535 GST_ats_new_session (const struct GNUNET_HELLO_Address *address,
536 struct Session *session)
538 struct AddressInfo *ai;
540 ai = find_ai (address, NULL);
543 /* We may simply already be aware of the session, even if some
544 other part of the code could not tell if it just created a new
545 session or just got one recycled from the plugin; hence, we may
546 be called with "new" session even for an "old" session; in that
547 case, check that this is the case, but just ignore it. */
548 GNUNET_assert (NULL != (find_ai (address, session)));
551 GNUNET_assert (NULL == ai->session);
552 ai->session = session;
553 LOG (GNUNET_ERROR_TYPE_DEBUG,
554 "Telling ATS about new session for peer %s\n",
555 GNUNET_i2s (&address->peer));
556 /* Note that the address might currently be blocked; we only
557 tell ATS about the session if the address is currently not
558 blocked; otherwise, ATS will be told about the session on
561 GNUNET_ATS_address_add_session (ai->ar,
564 GNUNET_assert (NULL != ai->unblock_task);
569 * Release memory used by the given address data.
571 * @param ai the `struct AddressInfo`
574 destroy_ai (struct AddressInfo *ai)
576 GNUNET_assert (NULL == ai->session);
577 if (NULL != ai->unblock_task)
579 GNUNET_SCHEDULER_cancel (ai->unblock_task);
580 ai->unblock_task = NULL;
583 GNUNET_assert (GNUNET_YES ==
584 GNUNET_CONTAINER_multipeermap_remove (p2a,
587 LOG (GNUNET_ERROR_TYPE_DEBUG,
588 "Telling ATS to destroy address from peer %s\n",
589 GNUNET_i2s (&ai->address->peer));
592 GNUNET_ATS_address_destroy (ai->ar);
595 publish_p2a_stat_update ();
596 GNUNET_HELLO_address_free (ai->address);
602 * Notify ATS that the @a session (but not the @a address) of
603 * a given @a address is no longer relevant. (The @a session
604 * went down.) This function may be called even if for the
605 * respective outbound address #GST_ats_new_session() was
606 * never called and thus the pair is unknown to ATS. In this
607 * case, the call is simply ignored.
609 * @param address the address
610 * @param session the session
613 GST_ats_del_session (const struct GNUNET_HELLO_Address *address,
614 struct Session *session)
616 struct AddressInfo *ai;
623 ai = find_ai (address,
627 /* We sometimes create sessions just for sending a PING,
628 and if those are destroyed they were never known to
629 ATS which means we end up here (however, in this
630 case, the address must be an outbound address). */
631 GNUNET_break (GNUNET_YES !=
632 GNUNET_HELLO_address_check_option (address,
633 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
636 GNUNET_assert (session == ai->session);
638 LOG (GNUNET_ERROR_TYPE_DEBUG,
639 "Telling ATS to destroy session %p from peer %s\n",
641 GNUNET_i2s (&address->peer));
642 if (GNUNET_YES == ai->expired)
644 /* last reason to keep this 'ai' around is now gone, the
645 session is dead as well, clean up */
648 /* Address expired but not blocked, and thus 'ar' was still
649 live because of the session; deleting just the session
650 will do for an inbound session, but for an outbound we
651 then also need to destroy the address with ATS. */
653 GNUNET_ATS_address_del_session (ai->ar,
656 GNUNET_ATS_address_destroy (ai->ar);
658 /* "ar" has been freed, regardless how the branch
659 above played out: it was either freed in
660 #GNUNET_ATS_address_del_session() because it was
661 incoming, or explicitly in
662 #GNUNET_ATS_address_del_session(). */
671 /* If ATS doesn't know about the address/session, this means
672 this address was blocked. */
674 GNUNET_HELLO_address_check_option (address,
675 GNUNET_HELLO_ADDRESS_INFO_INBOUND))
677 /* This was a blocked inbound session, which now lost the
678 session. But inbound addresses are by themselves useless,
679 so we must forget about the address as well. */
683 /* Otherwise, we are done as we have set `ai->session` to NULL
684 already and ATS will simply not be told about the session when
685 the connection is unblocked and the outbound address becomes
686 available again. . */
690 /* This is the "simple" case where ATS knows about the session and
691 the address is neither blocked nor expired. Delete the session,
692 and if it was inbound, free the address as well. */
694 GNUNET_ATS_address_del_session (ai->ar,
697 /* This was an inbound address, the session is now gone, so we
698 need to also forget about the address itself. */
706 * Notify ATS about DV @a distance change to an @a address.
707 * Does nothing if the @a address is not known to us.
709 * @param address the address
710 * @param distance new distance value
713 GST_ats_update_distance (const struct GNUNET_HELLO_Address *address,
716 struct AddressInfo *ai;
718 ai = find_ai_no_session (address);
721 /* We do not know about this address, do nothing. */
724 LOG (GNUNET_ERROR_TYPE_DEBUG,
725 "Updated distance for peer `%s' to %u\n",
726 GNUNET_i2s (&address->peer),
728 ai->properties.distance = distance;
729 /* Give manipulation its chance to change metrics */
730 GST_manipulation_manipulate_metrics (address,
733 /* Address may be blocked, only give ATS if address is
736 GNUNET_ATS_address_update (ai->ar,
742 * Notify ATS about @a delay changes to properties of an @a address.
743 * Does nothing if the @a address is not known to us.
745 * @param address the address
746 * @param delay new delay value
749 GST_ats_update_delay (const struct GNUNET_HELLO_Address *address,
750 struct GNUNET_TIME_Relative delay)
752 struct AddressInfo *ai;
754 ai = find_ai_no_session (address);
757 /* We do not know about this address, do nothing. */
760 LOG (GNUNET_ERROR_TYPE_DEBUG,
761 "Updated latency for peer `%s' to %s\n",
762 GNUNET_i2s (&address->peer),
763 GNUNET_STRINGS_relative_time_to_string (delay,
765 ai->properties.delay = delay;
766 /* Give manipulation its chance to change metrics */
767 GST_manipulation_manipulate_metrics (address,
770 /* Address may be blocked, only give ATS if address is
773 GNUNET_ATS_address_update (ai->ar,
779 * Notify ATS about utilization changes to an @a address.
780 * Does nothing if the @a address is not known to us.
782 * @param address our information about the address
783 * @param bps_in new utilization inbound
784 * @param bps_out new utilization outbound
787 GST_ats_update_utilization (const struct GNUNET_HELLO_Address *address,
791 struct AddressInfo *ai;
793 ai = find_ai_no_session (address);
796 /* We do not know about this address, do nothing. */
799 LOG (GNUNET_ERROR_TYPE_DEBUG,
800 "Updating utilization for peer `%s' address %s: %u/%u\n",
801 GNUNET_i2s (&address->peer),
802 GST_plugins_a2s (address),
803 (unsigned int) bps_in,
804 (unsigned int) bps_out);
805 ai->properties.utilization_in = bps_in;
806 ai->properties.utilization_out = bps_out;
807 /* Give manipulation its chance to change metrics */
808 GST_manipulation_manipulate_metrics (address,
811 /* Address may be blocked, only give ATS if address is
814 GNUNET_ATS_address_update (ai->ar,
820 * Notify ATS that the address has expired and thus cannot
821 * be used any longer. This function must only be called
822 * if the corresponding session is already gone.
824 * @param address the address
827 GST_ats_expire_address (const struct GNUNET_HELLO_Address *address)
829 struct AddressInfo *ai;
831 LOG (GNUNET_ERROR_TYPE_DEBUG,
832 "Address %s of peer %s expired\n",
833 GST_plugins_a2s (address),
834 GNUNET_i2s (&address->peer));
835 ai = find_ai_no_session (address);
841 if (NULL != ai->session)
843 /* Got an active session, just remember the expiration
844 and act upon it when the session goes down. */
845 ai->expired = GNUNET_YES;
848 /* Address expired, no session, free resources */
854 * Initialize ATS subsystem.
859 p2a = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_YES);
864 * Release memory used by the given address data.
867 * @param key which peer is this about
868 * @param value the `struct AddressInfo`
869 * @return #GNUNET_OK (continue to iterate)
872 destroy_ai_cb (void *cls,
873 const struct GNUNET_PeerIdentity *key,
876 struct AddressInfo *ai = value;
884 * Shutdown ATS subsystem.
889 GNUNET_CONTAINER_multipeermap_iterate (p2a,
892 publish_p2a_stat_update ();
893 GNUNET_CONTAINER_multipeermap_destroy (p2a);
897 /* end of gnunet-service-transport_ats.c */