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
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 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,
347 /* already blocked but this might be a blacklist check callback */
350 ai->back_off = GNUNET_TIME_STD_BACKOFF (ai->back_off);
352 GNUNET_HELLO_address_check_option (address,
353 GNUNET_HELLO_ADDRESS_INFO_INBOUND))
354 LOG (GNUNET_ERROR_TYPE_DEBUG,
355 "Removing address %s of peer %s from use (inbound died)\n",
356 GST_plugins_a2s (address),
357 GNUNET_i2s (&address->peer));
359 LOG (GNUNET_ERROR_TYPE_INFO,
360 "Blocking address %s of peer %s from use for %s\n",
361 GST_plugins_a2s (address),
362 GNUNET_i2s (&address->peer),
363 GNUNET_STRINGS_relative_time_to_string (ai->back_off,
365 /* destroy session and address */
366 if ( (NULL == session) ||
368 GNUNET_ATS_address_del_session (ai->ar,
371 GNUNET_ATS_address_destroy (ai->ar);
373 /* "ar" has been freed, regardless how the branch
374 above played out: it was either freed in
375 #GNUNET_ATS_address_del_session() because it was
376 incoming, or explicitly in
377 #GNUNET_ATS_address_del_session(). */
380 /* determine when the address should come back to life */
381 ai->blocked = GNUNET_TIME_relative_to_absolute (ai->back_off);
382 ai->unblock_task = GNUNET_SCHEDULER_add_delayed (ai->back_off,
386 publish_p2a_stat_update ();
391 * Reset address blocking time. Resets the exponential
392 * back-off timer for this address to zero. Called when
393 * an address was used to create a successful connection.
395 * @param address the address to reset the blocking timer
396 * @param session the session (can be NULL)
399 GST_ats_block_reset (const struct GNUNET_HELLO_Address *address,
400 struct GNUNET_ATS_Session *session)
402 struct AddressInfo *ai;
405 memcmp (&GST_my_identity,
407 sizeof (struct GNUNET_PeerIdentity)))
408 return; /* our own, ignore! */
409 ai = find_ai (address, session);
415 /* address is in successful use, so it should not be blocked right now */
416 GNUNET_break (NULL == ai->unblock_task);
417 ai->back_off = GNUNET_TIME_UNIT_ZERO;
422 * Notify ATS about a new inbound @a address. The @a address in
423 * combination with the @a session must be new, but this function will
424 * perform a santiy check. If the @a address is indeed new, make it
427 * @param address the address
428 * @param session the session
429 * @param prop performance information
432 GST_ats_add_inbound_address (const struct GNUNET_HELLO_Address *address,
433 struct GNUNET_ATS_Session *session,
434 const struct GNUNET_ATS_Properties *prop)
436 struct GNUNET_ATS_AddressRecord *ar;
437 struct AddressInfo *ai;
440 memcmp (&GST_my_identity,
442 sizeof (struct GNUNET_PeerIdentity)))
443 return; /* our own, ignore! */
445 /* Sanity checks for a valid inbound address */
446 if (NULL == address->transport_name)
451 GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != prop->scope);
452 GNUNET_assert (GNUNET_YES ==
453 GNUNET_HELLO_address_check_option (address,
454 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
455 GNUNET_assert (NULL != session);
456 ai = find_ai (address, session);
459 /* This should only be called for new sessions, and thus
460 we should not already have the address */
464 /* Is indeed new, let's tell ATS */
465 LOG (GNUNET_ERROR_TYPE_DEBUG,
466 "Notifying ATS about peer `%s''s new inbound address `%s' session %p in network %s\n",
467 GNUNET_i2s (&address->peer),
468 GST_plugins_a2s (address),
470 GNUNET_ATS_print_network_type (prop->scope));
471 ar = GNUNET_ATS_address_add (GST_ats,
475 GNUNET_assert (NULL != ar);
476 ai = GNUNET_new (struct AddressInfo);
477 ai->address = GNUNET_HELLO_address_copy (address);
478 ai->session = session;
479 ai->properties = *prop;
481 (void) GNUNET_CONTAINER_multipeermap_put (p2a,
484 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
485 publish_p2a_stat_update ();
490 * Notify ATS about the new address including the network this address is
491 * located in. The address must NOT be inbound and must be new to ATS.
493 * @param address the address
494 * @param prop performance information
497 GST_ats_add_address (const struct GNUNET_HELLO_Address *address,
498 const struct GNUNET_ATS_Properties *prop)
500 struct GNUNET_ATS_AddressRecord *ar;
501 struct AddressInfo *ai;
504 memcmp (&GST_my_identity,
506 sizeof (struct GNUNET_PeerIdentity)))
507 return; /* our own, ignore! */
508 /* validadte address */
509 if (NULL == address->transport_name)
514 GNUNET_assert (GNUNET_YES !=
515 GNUNET_HELLO_address_check_option (address,
516 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
517 ai = find_ai_no_session (address);
518 GNUNET_assert (NULL == ai);
519 GNUNET_break (GNUNET_ATS_NET_UNSPECIFIED != prop->scope);
521 /* address seems sane, let's tell ATS */
522 LOG (GNUNET_ERROR_TYPE_INFO,
523 "Notifying ATS about peer %s's new address `%s'\n",
524 GNUNET_i2s (&address->peer),
525 GST_plugins_a2s (address));
526 ar = GNUNET_ATS_address_add (GST_ats,
530 GNUNET_assert (NULL != ar);
531 ai = GNUNET_new (struct AddressInfo);
532 ai->address = GNUNET_HELLO_address_copy (address);
534 ai->properties = *prop;
535 (void) GNUNET_CONTAINER_multipeermap_put (p2a,
538 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
539 publish_p2a_stat_update ();
544 * Notify ATS about a new @a session now existing for the given
545 * @a address. Essentially, an outbound @a address was used
546 * to establish a @a session. It is safe to call this function
547 * repeatedly for the same @a address and @a session pair.
549 * @param address the address
550 * @param session the session
553 GST_ats_new_session (const struct GNUNET_HELLO_Address *address,
554 struct GNUNET_ATS_Session *session)
556 struct AddressInfo *ai;
559 memcmp (&GST_my_identity,
561 sizeof (struct GNUNET_PeerIdentity)))
562 return; /* our own, ignore! */
563 ai = find_ai (address, NULL);
566 /* We may simply already be aware of the session, even if some
567 other part of the code could not tell if it just created a new
568 session or just got one recycled from the plugin; hence, we may
569 be called with "new" session even for an "old" session; in that
570 case, check that this is the case, but just ignore it. */
571 GNUNET_assert (NULL != (find_ai (address, session)));
574 GNUNET_assert (NULL == ai->session);
575 ai->session = session;
576 LOG (GNUNET_ERROR_TYPE_DEBUG,
577 "Telling ATS about new session for peer %s\n",
578 GNUNET_i2s (&address->peer));
579 /* Note that the address might currently be blocked; we only
580 tell ATS about the session if the address is currently not
581 blocked; otherwise, ATS will be told about the session on
584 GNUNET_ATS_address_add_session (ai->ar,
587 GNUNET_assert (NULL != ai->unblock_task);
592 * Release memory used by the given address data.
594 * @param ai the `struct AddressInfo`
597 destroy_ai (struct AddressInfo *ai)
599 GNUNET_assert (NULL == ai->session);
600 if (NULL != ai->unblock_task)
602 GNUNET_SCHEDULER_cancel (ai->unblock_task);
603 ai->unblock_task = NULL;
606 GNUNET_assert (GNUNET_YES ==
607 GNUNET_CONTAINER_multipeermap_remove (p2a,
610 LOG (GNUNET_ERROR_TYPE_DEBUG,
611 "Telling ATS to destroy address from peer %s\n",
612 GNUNET_i2s (&ai->address->peer));
615 GNUNET_ATS_address_destroy (ai->ar);
618 publish_p2a_stat_update ();
619 GNUNET_HELLO_address_free (ai->address);
625 * Notify ATS that the @a session (but not the @a address) of
626 * a given @a address is no longer relevant. (The @a session
627 * went down.) This function may be called even if for the
628 * respective outbound address #GST_ats_new_session() was
629 * never called and thus the pair is unknown to ATS. In this
630 * case, the call is simply ignored.
632 * @param address the address
633 * @param session the session
636 GST_ats_del_session (const struct GNUNET_HELLO_Address *address,
637 struct GNUNET_ATS_Session *session)
639 struct AddressInfo *ai;
642 memcmp (&GST_my_identity,
644 sizeof (struct GNUNET_PeerIdentity)))
645 return; /* our own, ignore! */
651 ai = find_ai (address,
655 /* We sometimes create sessions just for sending a PING,
656 and if those are destroyed they were never known to
657 ATS which means we end up here (however, in this
658 case, the address must be an outbound address). */
659 GNUNET_break (GNUNET_YES !=
660 GNUNET_HELLO_address_check_option (address,
661 GNUNET_HELLO_ADDRESS_INFO_INBOUND));
664 GNUNET_assert (session == ai->session);
666 LOG (GNUNET_ERROR_TYPE_DEBUG,
667 "Telling ATS to destroy session %p from peer %s\n",
669 GNUNET_i2s (&address->peer));
670 if (GNUNET_YES == ai->expired)
672 /* last reason to keep this 'ai' around is now gone, the
673 session is dead as well, clean up */
676 /* Address expired but not blocked, and thus 'ar' was still
677 live because of the session; deleting just the session
678 will do for an inbound session, but for an outbound we
679 then also need to destroy the address with ATS. */
681 GNUNET_ATS_address_del_session (ai->ar,
684 GNUNET_ATS_address_destroy (ai->ar);
686 /* "ar" has been freed, regardless how the branch
687 above played out: it was either freed in
688 #GNUNET_ATS_address_del_session() because it was
689 incoming, or explicitly in
690 #GNUNET_ATS_address_del_session(). */
699 /* If ATS doesn't know about the address/session, this means
700 this address was blocked. */
702 GNUNET_HELLO_address_check_option (address,
703 GNUNET_HELLO_ADDRESS_INFO_INBOUND))
705 /* This was a blocked inbound session, which now lost the
706 session. But inbound addresses are by themselves useless,
707 so we must forget about the address as well. */
711 /* Otherwise, we are done as we have set `ai->session` to NULL
712 already and ATS will simply not be told about the session when
713 the connection is unblocked and the outbound address becomes
714 available again. . */
718 /* This is the "simple" case where ATS knows about the session and
719 the address is neither blocked nor expired. Delete the session,
720 and if it was inbound, free the address as well. */
722 GNUNET_ATS_address_del_session (ai->ar,
725 /* This was an inbound address, the session is now gone, so we
726 need to also forget about the address itself. */
734 * Notify ATS about DV @a distance change to an @a address.
735 * Does nothing if the @a address is not known to us.
737 * @param address the address
738 * @param distance new distance value
741 GST_ats_update_distance (const struct GNUNET_HELLO_Address *address,
744 struct AddressInfo *ai;
746 ai = find_ai_no_session (address);
749 /* We do not know about this address, do nothing. */
752 LOG (GNUNET_ERROR_TYPE_DEBUG,
753 "Updated distance for peer `%s' to %u\n",
754 GNUNET_i2s (&address->peer),
756 ai->properties.distance = distance;
757 /* Give manipulation its chance to change metrics */
758 GST_manipulation_manipulate_metrics (address,
761 /* Address may be blocked, only give ATS if address is
764 GNUNET_ATS_address_update (ai->ar,
770 * Notify ATS about @a delay changes to properties of an @a address.
771 * Does nothing if the @a address is not known to us.
773 * @param address the address
774 * @param delay new delay value
777 GST_ats_update_delay (const struct GNUNET_HELLO_Address *address,
778 struct GNUNET_TIME_Relative delay)
780 struct AddressInfo *ai;
782 ai = find_ai_no_session (address);
785 /* We do not know about this address, do nothing. */
788 LOG (GNUNET_ERROR_TYPE_DEBUG,
789 "Updated latency for peer `%s' to %s\n",
790 GNUNET_i2s (&address->peer),
791 GNUNET_STRINGS_relative_time_to_string (delay,
793 ai->properties.delay = delay;
794 /* Give manipulation its chance to change metrics */
795 GST_manipulation_manipulate_metrics (address,
798 /* Address may be blocked, only give ATS if address is
801 GNUNET_ATS_address_update (ai->ar,
807 * Notify ATS about utilization changes to an @a address.
808 * Does nothing if the @a address is not known to us.
810 * @param address our information about the address
811 * @param bps_in new utilization inbound
812 * @param bps_out new utilization outbound
815 GST_ats_update_utilization (const struct GNUNET_HELLO_Address *address,
819 struct AddressInfo *ai;
821 ai = find_ai_no_session (address);
824 /* We do not know about this address, do nothing. */
827 LOG (GNUNET_ERROR_TYPE_DEBUG,
828 "Updating utilization for peer `%s' address %s: %u/%u\n",
829 GNUNET_i2s (&address->peer),
830 GST_plugins_a2s (address),
831 (unsigned int) bps_in,
832 (unsigned int) bps_out);
833 ai->properties.utilization_in = bps_in;
834 ai->properties.utilization_out = bps_out;
835 /* Give manipulation its chance to change metrics */
836 GST_manipulation_manipulate_metrics (address,
839 /* Address may be blocked, only give ATS if address is
842 GNUNET_ATS_address_update (ai->ar,
848 * Notify ATS that the address has expired and thus cannot
849 * be used any longer. This function must only be called
850 * if the corresponding session is already gone.
852 * @param address the address
855 GST_ats_expire_address (const struct GNUNET_HELLO_Address *address)
857 struct AddressInfo *ai;
860 memcmp (&GST_my_identity,
862 sizeof (struct GNUNET_PeerIdentity)))
863 return; /* our own, ignore! */
864 LOG (GNUNET_ERROR_TYPE_DEBUG,
865 "Address %s of peer %s expired\n",
866 GST_plugins_a2s (address),
867 GNUNET_i2s (&address->peer));
868 ai = find_ai_no_session (address);
874 if (NULL != ai->session)
876 /* Got an active session, just remember the expiration
877 and act upon it when the session goes down. */
878 ai->expired = GNUNET_YES;
881 /* Address expired, no session, free resources */
887 * Initialize ATS subsystem.
892 p2a = GNUNET_CONTAINER_multipeermap_create (4, GNUNET_YES);
897 * Release memory used by the given address data.
900 * @param key which peer is this about
901 * @param value the `struct AddressInfo`
902 * @return #GNUNET_OK (continue to iterate)
905 destroy_ai_cb (void *cls,
906 const struct GNUNET_PeerIdentity *key,
909 struct AddressInfo *ai = value;
917 * Shutdown ATS subsystem.
922 GNUNET_CONTAINER_multipeermap_iterate (p2a,
925 publish_p2a_stat_update ();
926 GNUNET_CONTAINER_multipeermap_destroy (p2a);
930 /* end of gnunet-service-transport_ats.c */