2 This file is part of GNUnet.
3 (C) 2010,2011 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., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @brief automatic transport selection API
23 * @author Christian Grothoff
24 * @author Matthias Wachs
28 * - extend API to get performance data
29 * - implement simplistic strategy based on say 'lowest latency' or strict ordering
30 * - extend API to get peer preferences, implement proportional bandwidth assignment
31 * - re-implement API against a real ATS service (!)
34 #include "gnunet_ats_service.h"
36 // NOTE: this implementation is simply supposed
37 // to implement a simplistic strategy in-process;
38 // in the future, we plan to replace it with a real
39 // service implementation
42 * Allocation record for a peer's address.
44 struct AllocationRecord
48 * Performance information associated with this address (array).
50 struct GNUNET_TRANSPORT_ATS_Information *ats;
58 * Address this record represents, allocated at the end of this struct.
60 const void *plugin_addr;
63 * Session associated with this record.
65 struct Session *session;
68 * Number of bytes in plugin_addr.
70 size_t plugin_addr_len;
73 * Number of entries in 'ats'.
78 * Bandwidth assigned to this address right now, 0 for none.
80 struct GNUNET_BANDWIDTH_Value32NBO bandwidth;
83 * Set to GNUNET_YES if this is the connected address of a connected peer.
91 * Opaque handle to obtain address suggestions.
93 struct GNUNET_ATS_SuggestionContext
97 * Function to call with our final suggestion.
99 GNUNET_ATS_AddressSuggestionCallback cb;
109 struct GNUNET_ATS_Handle *atc;
112 * Which peer are we monitoring?
114 struct GNUNET_PeerIdentity target;
120 * Handle to the ATS subsystem.
122 struct GNUNET_ATS_Handle
127 const struct GNUNET_CONFIGURATION_Handle *cfg;
130 * Function to call when the allocation changes.
132 GNUNET_TRANSPORT_ATS_AllocationNotification alloc_cb;
135 * Closure for 'alloc_cb'.
140 * Information about all connected peers. Maps peer identities
141 * to one or more 'struct AllocationRecord' values.
143 struct GNUNET_CONTAINER_MultiHashMap *peers;
146 * Map of PeerIdentities to 'struct GNUNET_ATS_SuggestionContext's.
148 struct GNUNET_CONTAINER_MultiHashMap *notify_map;
152 * Task scheduled to update our bandwidth assignment.
154 GNUNET_SCHEDULER_TaskIdentifier ba_task;
157 * Total bandwidth per configuration.
159 unsigned long long total_bps;
164 * Count number of connected records.
166 * @param cls pointer to counter
167 * @param key identity of the peer associated with the records
168 * @param value a 'struct AllocationRecord'
169 * @return GNUNET_YES (continue iteration)
172 count_connections (void *cls, const GNUNET_HashCode * key, void *value)
174 unsigned int *ac = cls;
175 struct AllocationRecord *ar = value;
177 if (GNUNET_YES == ar->connected)
184 * Closure for 'set_bw_connections'.
186 struct SetBandwidthContext
191 struct GNUNET_ATS_Handle *atc;
194 * Bandwidth to assign.
196 struct GNUNET_BANDWIDTH_Value32NBO bw;
201 * Set bandwidth based on record.
203 * @param cls 'struct SetBandwidthContext'
204 * @param key identity of the peer associated with the records
205 * @param value a 'struct AllocationRecord'
206 * @return GNUNET_YES (continue iteration)
209 set_bw_connections (void *cls, const GNUNET_HashCode * key, void *value)
211 struct SetBandwidthContext *sbc = cls;
212 struct AllocationRecord *ar = value;
214 if (GNUNET_YES == ar->connected)
216 ar->bandwidth = sbc->bw;
217 sbc->atc->alloc_cb (sbc->atc->alloc_cb_cls,
218 (const struct GNUNET_PeerIdentity *) key,
219 ar->plugin_name, ar->session, ar->plugin_addr,
220 ar->plugin_addr_len, ar->bandwidth);
222 else if (ntohl (ar->bandwidth.value__) > 0)
224 ar->bandwidth = GNUNET_BANDWIDTH_value_init (0);
225 sbc->atc->alloc_cb (sbc->atc->alloc_cb_cls,
226 (const struct GNUNET_PeerIdentity *) key,
227 ar->plugin_name, ar->session, ar->plugin_addr,
228 ar->plugin_addr_len, ar->bandwidth);
235 * Task run to update bandwidth assignments.
237 * @param cls the 'struct GNUNET_ATS_Handle'
238 * @param tc scheduler context
241 update_bandwidth_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
243 struct GNUNET_ATS_Handle *atc = cls;
245 struct SetBandwidthContext bwc;
247 atc->ba_task = GNUNET_SCHEDULER_NO_TASK;
248 /* FIXME: update calculations NICELY; what follows is a naive version */
249 GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &count_connections, &ac);
251 bwc.bw = GNUNET_BANDWIDTH_value_init (atc->total_bps / ac);
252 GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &set_bw_connections, &bwc);
257 * Calculate an updated bandwidth assignment and notify.
260 * @param change which allocation record changed?
263 update_bandwidth_assignment (struct GNUNET_ATS_Handle *atc,
264 struct AllocationRecord *change)
266 /* FIXME: based on the 'change', update the LP-problem... */
267 if (atc->ba_task == GNUNET_SCHEDULER_NO_TASK)
268 atc->ba_task = GNUNET_SCHEDULER_add_now (&update_bandwidth_task, atc);
273 * Function called with feasbile addresses we might want to suggest.
275 * @param cls the 'struct GNUNET_ATS_SuggestionContext'
276 * @param key identity of the peer
277 * @param value a 'struct AllocationRecord' for the peer
278 * @return GNUNET_NO if we're done, GNUNET_YES if we did not suggest an address yet
281 suggest_address (void *cls, const GNUNET_HashCode * key, void *value)
283 struct GNUNET_ATS_SuggestionContext *asc = cls;
284 struct AllocationRecord *ar = value;
286 /* trivial strategy: pick first available address... */
287 asc->cb (asc->cb_cls, &asc->target, ar->plugin_name, ar->plugin_addr,
288 ar->plugin_addr_len, ar->session,
289 GNUNET_BANDWIDTH_value_init (asc->atc->total_bps / 32), ar->ats,
297 * We would like to establish a new connection with a peer.
298 * ATS should suggest a good address to begin with.
301 * @param peer identity of the new peer
302 * @param cb function to call with the address
303 * @param cb_cls closure for cb
305 struct GNUNET_ATS_SuggestionContext *
306 GNUNET_ATS_suggest_address (struct GNUNET_ATS_Handle *atc,
307 const struct GNUNET_PeerIdentity *peer,
308 GNUNET_ATS_AddressSuggestionCallback cb,
311 struct GNUNET_ATS_SuggestionContext *asc;
313 asc = GNUNET_malloc (sizeof (struct GNUNET_ATS_SuggestionContext));
315 asc->cb_cls = cb_cls;
318 GNUNET_CONTAINER_multihashmap_get_multiple (atc->peers, &peer->hashPubKey,
319 &suggest_address, asc);
325 GNUNET_CONTAINER_multihashmap_put (atc->notify_map, &peer->hashPubKey, asc,
326 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
332 * Cancel suggestion request.
334 * @param asc handle of the request to cancel
337 GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SuggestionContext *asc)
339 GNUNET_assert (GNUNET_OK ==
340 GNUNET_CONTAINER_multihashmap_remove (asc->atc->notify_map,
341 &asc->target.hashPubKey,
348 * Initialize the ATS subsystem.
350 * @param cfg configuration to use
351 * @param alloc_cb notification to call whenever the allocation changed
352 * @param alloc_cb_cls closure for 'alloc_cb'
353 * @return ats context
355 struct GNUNET_ATS_Handle *
356 GNUNET_ATS_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
357 GNUNET_TRANSPORT_ATS_AllocationNotification alloc_cb,
360 struct GNUNET_ATS_Handle *atc;
362 atc = GNUNET_malloc (sizeof (struct GNUNET_ATS_Handle));
364 atc->alloc_cb = alloc_cb;
365 atc->alloc_cb_cls = alloc_cb_cls;
366 atc->peers = GNUNET_CONTAINER_multihashmap_create (256);
367 atc->notify_map = GNUNET_CONTAINER_multihashmap_create (256);
368 GNUNET_CONFIGURATION_get_value_number (cfg, "core", "TOTAL_QUOTA_OUT",
375 * Free an allocation record.
378 * @param key identity of the peer associated with the record
379 * @param value the 'struct AllocationRecord' to free
380 * @return GNUNET_OK (continue to iterate)
383 destroy_allocation_record (void *cls, const GNUNET_HashCode * key, void *value)
385 struct AllocationRecord *ar = value;
387 GNUNET_array_grow (ar->ats, ar->ats_count, 0);
388 GNUNET_free (ar->plugin_name);
395 * Shutdown the ATS subsystem.
400 GNUNET_ATS_shutdown (struct GNUNET_ATS_Handle *atc)
402 if (GNUNET_SCHEDULER_NO_TASK != atc->ba_task)
404 GNUNET_SCHEDULER_cancel (atc->ba_task);
405 atc->ba_task = GNUNET_SCHEDULER_NO_TASK;
407 GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &destroy_allocation_record,
409 GNUNET_CONTAINER_multihashmap_destroy (atc->peers);
410 GNUNET_assert (GNUNET_CONTAINER_multihashmap_size (atc->notify_map) == 0);
411 GNUNET_CONTAINER_multihashmap_destroy (atc->notify_map);
412 atc->notify_map = NULL;
418 * Closure for 'update_session'
420 struct UpdateSessionContext
425 struct GNUNET_ATS_Handle *atc;
428 * Allocation record with new information.
430 struct AllocationRecord *arnew;
435 * Update an allocation record, merging with the new information
437 * @param cls a new 'struct AllocationRecord'
438 * @param key identity of the peer associated with the records
439 * @param value the old 'struct AllocationRecord'
440 * @return GNUNET_YES if the records do not match,
441 * GNUNET_NO if the record do match and 'old' was updated
444 update_session (void *cls, const GNUNET_HashCode * key, void *value)
446 struct UpdateSessionContext *usc = cls;
447 struct AllocationRecord *arnew = usc->arnew;
448 struct AllocationRecord *arold = value;
451 if (0 != strcmp (arnew->plugin_name, arold->plugin_name))
453 if ((arnew->session == arold->session) ||
454 ((arold->session == NULL) &&
455 (arold->plugin_addr_len == arnew->plugin_addr_len) &&
457 memcmp (arold->plugin_addr, arnew->plugin_addr,
458 arnew->plugin_addr_len))))
462 if (arnew->session != arold->session)
464 arold->session = arnew->session;
467 if ((arnew->connected == GNUNET_YES) && (arold->connected == GNUNET_NO))
469 arold->connected = GNUNET_YES;
472 // FIXME: merge ats arrays of (arold, arnew);
474 if (GNUNET_YES == change)
475 update_bandwidth_assignment (usc->atc, arold);
483 * Create an allocation record with the given properties.
485 * @param plugin_name name of the currently used transport plugin
486 * @param session session in use (if available)
487 * @param plugin_addr address in use (if available)
488 * @param plugin_addr_len number of bytes in plugin_addr
489 * @param ats performance data for the connection
490 * @param ats_count number of performance records in 'ats'
492 static struct AllocationRecord *
493 create_allocation_record (const char *plugin_name, struct Session *session,
494 const void *plugin_addr, size_t plugin_addr_len,
495 const struct GNUNET_TRANSPORT_ATS_Information *ats,
498 struct AllocationRecord *ar;
500 ar = GNUNET_malloc (sizeof (struct AllocationRecord) + plugin_addr_len);
501 ar->plugin_name = GNUNET_strdup (plugin_name);
502 ar->plugin_addr = &ar[1];
503 memcpy (&ar[1], plugin_addr, plugin_addr_len);
504 ar->session = session;
505 ar->plugin_addr_len = plugin_addr_len;
506 GNUNET_array_grow (ar->ats, ar->ats_count, ats_count);
507 memcpy (ar->ats, ats,
508 ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
514 * Mark all matching allocation records as not connected.
516 * @param cls 'struct GTS_AtsHandle'
517 * @param key identity of the peer associated with the record
518 * @param value the 'struct AllocationRecord' to clear the 'connected' flag
519 * @return GNUNET_OK (continue to iterate)
522 disconnect_peer (void *cls, const GNUNET_HashCode * key, void *value)
524 struct GNUNET_ATS_Handle *atc = cls;
525 struct AllocationRecord *ar = value;
527 if (GNUNET_YES == ar->connected)
529 ar->connected = GNUNET_NO;
530 update_bandwidth_assignment (atc, ar);
537 * We established a new connection with a peer (for example, because
538 * core asked for it or because the other peer connected to us).
539 * Calculate bandwidth assignments including the new peer.
542 * @param peer identity of the new peer
543 * @param plugin_name name of the currently used transport plugin
544 * @param session session in use (if available)
545 * @param plugin_addr address in use (if available)
546 * @param plugin_addr_len number of bytes in plugin_addr
547 * @param ats performance data for the connection
548 * @param ats_count number of performance records in 'ats'
551 GNUNET_ATS_peer_connect (struct GNUNET_ATS_Handle *atc,
552 const struct GNUNET_PeerIdentity *peer,
553 const char *plugin_name, struct Session *session,
554 const void *plugin_addr, size_t plugin_addr_len,
555 const struct GNUNET_TRANSPORT_ATS_Information *ats,
558 struct AllocationRecord *ar;
559 struct UpdateSessionContext usc;
561 (void) GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &disconnect_peer,
563 ar = create_allocation_record (plugin_name, session, plugin_addr,
564 plugin_addr_len, ats, ats_count);
565 ar->connected = GNUNET_YES;
569 GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &update_session, &usc))
571 destroy_allocation_record (NULL, &peer->hashPubKey, ar);
574 GNUNET_assert (GNUNET_OK ==
575 GNUNET_CONTAINER_multihashmap_put (atc->peers,
576 &peer->hashPubKey, ar,
577 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
582 * We disconnected from the given peer (for example, because ats, core
583 * or blacklist asked for it or because the other peer disconnected).
584 * Calculate bandwidth assignments without the peer.
587 * @param peer identity of the new peer
590 GNUNET_ATS_peer_disconnect (struct GNUNET_ATS_Handle *atc,
591 const struct GNUNET_PeerIdentity *peer)
593 (void) GNUNET_CONTAINER_multihashmap_get_multiple (atc->peers,
595 &disconnect_peer, atc);
600 * Closure for 'destroy_allocation_record'
602 struct SessionDestroyContext
607 struct GNUNET_ATS_Handle *atc;
610 * Session being destroyed.
612 const struct Session *session;
617 * Free an allocation record matching the given session.
619 * @param cls the 'struct SessionDestroyContext'
620 * @param key identity of the peer associated with the record
621 * @param value the 'struct AllocationRecord' to free
622 * @return GNUNET_OK (continue to iterate)
625 destroy_session (void *cls, const GNUNET_HashCode * key, void *value)
627 struct SessionDestroyContext *sdc = cls;
628 struct AllocationRecord *ar = value;
630 if (ar->session != sdc->session)
633 if (ar->plugin_addr != NULL)
635 GNUNET_assert (GNUNET_OK ==
636 GNUNET_CONTAINER_multihashmap_remove (sdc->atc->peers, key,
638 if (GNUNET_YES == ar->connected) ;
640 /* FIXME: is this supposed to be allowed? What to do then? */
643 destroy_allocation_record (NULL, key, ar);
649 * A session got destroyed, stop including it as a valid address.
652 * @param peer identity of the peer
653 * @param session session handle that is no longer valid
656 GNUNET_ATS_session_destroyed (struct GNUNET_ATS_Handle *atc,
657 const struct GNUNET_PeerIdentity *peer,
658 const struct Session *session)
660 struct SessionDestroyContext sdc;
663 sdc.session = session;
664 (void) GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &destroy_session,
670 * Notify validation watcher that an entry is now valid
672 * @param cls 'struct ValidationEntry' that is now valid
673 * @param key peer identity (unused)
674 * @param value a 'GST_ValidationIteratorContext' to notify
675 * @return GNUNET_YES (continue to iterate)
678 notify_valid (void *cls, const GNUNET_HashCode * key, void *value)
680 struct AllocationRecord *ar = cls;
681 struct GNUNET_ATS_SuggestionContext *asc = value;
683 asc->cb (asc->cb_cls, &asc->target, ar->plugin_name, ar->plugin_addr,
684 ar->plugin_addr_len, ar->session,
685 GNUNET_BANDWIDTH_value_init (asc->atc->total_bps / 32), ar->ats,
687 GNUNET_ATS_suggest_address_cancel (asc);
693 * We have updated performance statistics for a given address. Note
694 * that this function can be called for addresses that are currently
695 * in use as well as addresses that are valid but not actively in use.
696 * Furthermore, the peer may not even be connected to us right now (in
697 * which case the call may be ignored or the information may be stored
698 * for later use). Update bandwidth assignments.
701 * @param peer identity of the peer
702 * @param valid_until how long is the address valid?
703 * @param plugin_name name of the transport plugin
704 * @param session session handle (if available)
705 * @param plugin_addr address (if available)
706 * @param plugin_addr_len number of bytes in plugin_addr
707 * @param ats performance data for the address
708 * @param ats_count number of performance records in 'ats'
711 GNUNET_ATS_address_update (struct GNUNET_ATS_Handle *atc,
712 const struct GNUNET_PeerIdentity *peer,
713 struct GNUNET_TIME_Absolute valid_until,
714 const char *plugin_name, struct Session *session,
715 const void *plugin_addr, size_t plugin_addr_len,
716 const struct GNUNET_TRANSPORT_ATS_Information *ats,
719 struct AllocationRecord *ar;
720 struct UpdateSessionContext usc;
722 ar = create_allocation_record (plugin_name, session, plugin_addr,
723 plugin_addr_len, ats, ats_count);
727 GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &update_session, &usc))
729 destroy_allocation_record (NULL, &peer->hashPubKey, ar);
732 GNUNET_assert (GNUNET_OK ==
733 GNUNET_CONTAINER_multihashmap_put (atc->peers,
734 &peer->hashPubKey, ar,
735 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
736 GNUNET_CONTAINER_multihashmap_get_multiple (atc->notify_map,
737 &peer->hashPubKey, ¬ify_valid,
741 /* end of file gnunet-service-transport_ats.c */