X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fats%2Fgnunet-service-ats_addresses.c;h=49d6d0b593f71cb95783b7c87481179dc3e3e99a;hb=64e4ca7129e49dcc11a6db834107dda7ca1f9cf9;hp=75c158390c1b9ddf811466fb4c38772915b1a885;hpb=2b4ae5504a5a14f0308c54f083df789bae69bea2;p=oweals%2Fgnunet.git diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c index 75c158390..49d6d0b59 100644 --- a/src/ats/gnunet-service-ats_addresses.c +++ b/src/ats/gnunet-service-ats_addresses.c @@ -34,58 +34,162 @@ #if HAVE_LIBGLPK #include "gnunet-service-ats_addresses_mlp.h" #endif - -#define VERBOSE GNUNET_NO +#include "gnunet-service-ats_addresses_simplistic.h" #define ATS_BLOCKING_DELTA GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100) + +/** + * Available ressource assignment modes + */ enum ATS_Mode { /* + * Simplistic mode: + * * Assign each peer an equal amount of bandwidth (bw) * * bw_per_peer = bw_total / #active addresses */ - SIMPLE, + MODE_SIMPLISTIC, /* - * Use MLP solver to assign bandwidth + * MLP mode: + * + * Solve ressource assignment as an optimization problem + * Uses an mixed integer programming solver */ - MLP + MODE_MLP }; -static struct GNUNET_CONTAINER_MultiHashMap *addresses; +/** + * Handle for ATS address component + */ +struct GAS_Addresses_Handle +{ + /** + * A multihashmap to store all addresses + */ + struct GNUNET_CONTAINER_MultiHashMap *addresses; -#if HAVE_LIBGLPK -static struct GAS_MLP_Handle *mlp; -#endif + /** + * Configure WAN quota in + */ + unsigned long long wan_quota_in; -static unsigned long long wan_quota_in; + /** + * Configure WAN quota out + */ + unsigned long long wan_quota_out; -static unsigned long long wan_quota_out; + /** + * Number of active addresses + */ + unsigned int active_addr_count; -static unsigned int active_addr_count; + /** + * Is ATS addresses running + */ + int running; -static int ats_mode; + /** + * Configured ATS solver + */ + int ats_mode; -static int running; + /** + * Solver handle + */ + void *solver; + + /* Solver functions */ + /** + * Initialize solver + */ + GAS_solver_init s_init; + + /** + * Update address in solver + */ + GAS_solver_address_update s_update; + + /** + * Get address from solver + */ + GAS_solver_get_preferred_address s_get; + + /** + * Delete address in solver + */ + GAS_solver_address_delete s_del; + + /** + * Change preference for quality in solver + */ + GAS_solver_address_change_preference s_pref; + + /** + * Shutdown solver + */ + GAS_solver_done s_done; +}; + + +/** + * Temporary handle + */ +struct GAS_Addresses_Handle *handle; + + +static unsigned int +assemble_ats_information (struct ATS_Address *aa, struct GNUNET_ATS_Information **dest) +{ + unsigned int ats_count = GNUNET_ATS_PropertyCount - 1; + struct GNUNET_ATS_Information *ats = GNUNET_malloc (ats_count * sizeof (struct GNUNET_ATS_Information)); + (*dest) = ats; + + ats[0].type = ntohl(GNUNET_ATS_UTILIZATION_UP); + ats[0].value = aa->atsp_utilization_out.value__; + ats[1].type = ntohl(GNUNET_ATS_UTILIZATION_DOWN); + ats[1].value = aa->atsp_utilization_in.value__; + ats[2].type = ntohl(GNUNET_ATS_NETWORK_TYPE); + ats[2].value = ntohl(aa->atsp_network_type); + ats[3].type = ntohl(GNUNET_ATS_QUALITY_NET_DELAY); + ats[3].value = ntohl(aa->atsp_latency.rel_value); + ats[4].type = ntohl(GNUNET_ATS_QUALITY_NET_DISTANCE); + ats[4].value = ntohl(aa->atsp_distance); + ats[5].type = ntohl(GNUNET_ATS_COST_WAN); + ats[5].value = ntohl (aa->atsp_cost_wan); + ats[6].type = ntohl(GNUNET_ATS_COST_LAN); + ats[6].value = ntohl (aa->atsp_cost_lan); + ats[7].type = ntohl(GNUNET_ATS_COST_WLAN); + ats[7].value = ntohl (aa->atsp_cost_wlan); + return ats_count; +} static void send_bw_notification (struct ATS_Address *aa) { + struct GNUNET_ATS_Information *ats; + uint32_t ats_count; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New bandwidth for peer %s is %u/%u\n", GNUNET_i2s (&aa->peer), ntohl (aa->assigned_bw_in.value__), ntohl (aa->assigned_bw_out.value__)); + ats_count = assemble_ats_information (aa, &ats); + GAS_scheduling_transmit_address_suggestion (&aa->peer, aa->plugin, aa->addr, aa->addr_len, aa->session_id, - aa->ats, aa->ats_count, + ats, ats_count, aa->assigned_bw_out, aa->assigned_bw_in); GAS_reservations_set_bandwidth (&aa->peer, aa->assigned_bw_in); GAS_performance_notify_all_clients (&aa->peer, aa->plugin, aa->addr, aa->addr_len, - aa->ats, aa->ats_count, aa->assigned_bw_out, + aa->active, + ats, ats_count, aa->assigned_bw_out, aa->assigned_bw_in); + GNUNET_free (ats); } /** @@ -104,12 +208,12 @@ update_bw_simple_it (void *cls, const struct GNUNET_HashCode * key, void *value) if (GNUNET_YES != aa->active) return GNUNET_OK; - GNUNET_assert (active_addr_count > 0); + GNUNET_assert (handle->active_addr_count > 0); /* Simple method */ - aa->assigned_bw_in.value__ = htonl (wan_quota_in / active_addr_count); - aa->assigned_bw_out.value__ = htonl (wan_quota_out / active_addr_count); + aa->assigned_bw_in.value__ = htonl (handle->wan_quota_in / handle->active_addr_count); + aa->assigned_bw_out.value__ = htonl (handle->wan_quota_out / handle->active_addr_count); send_bw_notification (aa); @@ -128,10 +232,10 @@ recalculate_assigned_bw () "Recalculating bandwidth for all active connections\n"); GNUNET_STATISTICS_update (GSA_stats, "# bandwidth recalculations performed", 1, GNUNET_NO); - GNUNET_STATISTICS_set (GSA_stats, "# active addresses", active_addr_count, + GNUNET_STATISTICS_set (GSA_stats, "# active addresses", handle->active_addr_count, GNUNET_NO); - GNUNET_CONTAINER_multihashmap_iterate (addresses, &update_bw_simple_it, NULL); + GNUNET_CONTAINER_multihashmap_iterate (handle->addresses, &update_bw_simple_it, NULL); } /** @@ -187,18 +291,18 @@ destroy_address (struct ATS_Address *addr) ret = GNUNET_NO; GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove (addresses, + GNUNET_CONTAINER_multihashmap_remove (handle->addresses, &addr->peer.hashPubKey, addr)); #if HAVE_LIBGLPK - if (ats_mode == MLP) - GAS_mlp_address_delete (mlp, addresses, addr); + if (handle->ats_mode == MODE_MLP) + GAS_mlp_address_delete (handle->solver, handle->addresses, addr); #endif if (GNUNET_YES == addr->active) { - active_addr_count--; + handle->active_addr_count--; addr->active = GNUNET_NO; ret = GNUNET_YES; } @@ -307,7 +411,7 @@ find_address (const struct GNUNET_PeerIdentity *peer, cac.exact_address = NULL; cac.base_address = NULL; cac.search = addr; - GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, + GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &compare_address_it, &cac); #if 0 @@ -356,6 +460,8 @@ lookup_address (const struct GNUNET_PeerIdentity *peer, return old; } + +#if 0 static int compare_address_session_it (void *cls, const struct GNUNET_HashCode * key, void *value) { @@ -366,7 +472,7 @@ compare_address_session_it (void *cls, const struct GNUNET_HashCode * key, void { if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == cac->search->session_id)) { - cac->exact_address = aa; + cac->exact_address = aa; return GNUNET_NO; } } @@ -383,7 +489,7 @@ compare_address_session_it (void *cls, const struct GNUNET_HashCode * key, void * @param addr existing address record * @return existing address record, NULL for none */ -struct ATS_Address * +static struct ATS_Address * find_exact_address (const struct GNUNET_PeerIdentity *peer, const struct ATS_Address *addr) { @@ -391,11 +497,11 @@ find_exact_address (const struct GNUNET_PeerIdentity *peer, cac.exact_address = NULL; cac.search = addr; - GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, + GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &compare_address_session_it, &cac); return cac.exact_address; } - +#endif void GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, @@ -407,10 +513,10 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, struct ATS_Address *aa; struct ATS_Address *old; - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return; - GNUNET_assert (NULL != addresses); + GNUNET_assert (NULL != handle->addresses); aa = create_address (peer, plugin_name, @@ -428,7 +534,7 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, { /* We have a new address */ GNUNET_assert (GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put (addresses, + GNUNET_CONTAINER_multihashmap_put (handle->addresses, &peer->hashPubKey, aa, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new address for peer `%s' session id %u, %p\n", @@ -471,10 +577,10 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer, struct ATS_Address *old; uint32_t i; - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return; - GNUNET_assert (NULL != addresses); + GNUNET_assert (NULL != handle->addresses); /* Get existing address */ old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len, @@ -521,10 +627,9 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer, GNUNET_break (0); break; } -#if HAVE_LIBGLPK - if (ats_mode == MLP) - GAS_mlp_address_update (mlp, addresses, old); -#endif + + /* Tell solver about update */ + handle->s_update (handle->solver, handle->addresses, old); } @@ -569,42 +674,39 @@ destroy_by_session_id (void *cls, const struct GNUNET_HashCode * key, void *valu if (aa->session_id != 0) GNUNET_break (0 == strcmp (info->plugin, aa->plugin)); /* session died */ -#if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting session for peer `%s': `%s' %u\n", GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id); -#endif aa->session_id = 0; if (GNUNET_YES == aa->active) { aa->active = GNUNET_NO; - active_addr_count--; + handle->active_addr_count--; recalculate_assigned_bw (); } /* session == 0 and addrlen == 0 : destroy address */ if (aa->addr_len == 0) { -#if VERBOSE GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting session and address for peer `%s': `%s' %u\n", GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id); -#endif (void) destroy_address (aa); } else { /* session was set to 0, update address */ #if HAVE_LIBGLPK - if (ats_mode == MLP) - GAS_mlp_address_update (mlp, addresses, aa); + if (handle->ats_mode == MODE_MLP) + GAS_mlp_address_update (handle->solver, handle->addresses, aa); #endif } return GNUNET_OK; } + void GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, @@ -613,7 +715,7 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, struct ATS_Address *aa; struct ATS_Address *old; - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return; /* Get existing address */ @@ -621,9 +723,8 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, session_id, NULL, 0); if (old == NULL) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Tried to destroy unknown address for peer `%s' `%s' session id %u\n", + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tried to destroy unknown address for peer `%s' `%s' session id %u\n", GNUNET_i2s (peer), plugin_name, session_id); - GNUNET_break (0); return; } @@ -631,7 +732,7 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, GNUNET_break (0 < strlen (plugin_name)); aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); - GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, + GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &destroy_by_session_id, aa); free_address (aa); @@ -740,7 +841,7 @@ GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer, struct ATS_Address *old; - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return GNUNET_SYSERR; old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id, NULL, 0); @@ -765,21 +866,22 @@ GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer, return GNUNET_SYSERR; } old->used = in_use; -#if HAVE_LIBGLPK - if (ats_mode == MLP) - GAS_mlp_address_update (mlp, addresses, old); -#endif + + /* Tell solver about update */ + handle->s_update (handle->solver, handle->addresses, old); + return GNUNET_OK; } -void request_address_mlp (const struct GNUNET_PeerIdentity *peer) +static void +request_address_mlp (const struct GNUNET_PeerIdentity *peer) { struct ATS_Address *aa; aa = NULL; #if HAVE_GLPK - /* Get preferred address from MLP */ + /* Get preferred address from MODE_MLP */ struct ATS_PreferedAddress * paddr = NULL; paddr = GAS_mlp_get_preferred_address (mlp, addresses, peer); aa = paddr->address; @@ -799,8 +901,7 @@ void request_address_mlp (const struct GNUNET_PeerIdentity *peer) if (aa->active == GNUNET_NO) { aa->active = GNUNET_YES; - active_addr_count++; - + handle->active_addr_count++; send_bw_notification (aa); } else @@ -815,13 +916,15 @@ void request_address_mlp (const struct GNUNET_PeerIdentity *peer) } -void request_address_simple (const struct GNUNET_PeerIdentity *peer) + +static void +request_address_simple (const struct GNUNET_PeerIdentity *peer) { struct ATS_Address *aa; aa = NULL; /* Get address with: stick to current address, lower distance, lower latency */ - GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, + GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &find_address_it, &aa); if (aa == NULL) { @@ -836,8 +939,8 @@ void request_address_simple (const struct GNUNET_PeerIdentity *peer) if (aa->active == GNUNET_NO) { aa->active = GNUNET_YES; - active_addr_count++; - if (ats_mode == SIMPLE) + handle->active_addr_count++; + if (handle->ats_mode == MODE_SIMPLISTIC) { recalculate_assigned_bw (); } @@ -857,14 +960,14 @@ void request_address_simple (const struct GNUNET_PeerIdentity *peer) void GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer) { - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return; - if (ats_mode == SIMPLE) + if (handle->ats_mode == MODE_SIMPLISTIC) { request_address_simple (peer); } - if (ats_mode == MLP) + if (handle->ats_mode == MODE_MLP) { request_address_mlp(peer); } @@ -884,30 +987,27 @@ reset_address_it (void *cls, const struct GNUNET_HashCode * key, void *value) return GNUNET_OK; } + void GAS_addresses_handle_backoff_reset (const struct GNUNET_PeerIdentity *peer) { - GNUNET_break (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple (addresses, + GNUNET_break (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &reset_address_it, NULL)); } - -// FIXME: this function should likely end up in the LP-subsystem and -// not with 'addresses' in the future... void GAS_addresses_change_preference (const struct GNUNET_PeerIdentity *peer, enum GNUNET_ATS_PreferenceKind kind, float score) { - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return; -#if HAVE_LIBGLPK - if (ats_mode == MLP) - GAS_mlp_address_change_preference (mlp, peer, kind, score); -#endif + + /* Tell solver about update */ + handle->s_pref (handle->solver, peer, kind, score); } @@ -918,90 +1018,130 @@ GAS_addresses_change_preference (const struct GNUNET_PeerIdentity *peer, * @param cfg configuration to use * @param stats the statistics handle to use */ -void +struct GAS_Addresses_Handle * GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_STATISTICS_Handle *stats) { - int mode; - + struct GAS_Addresses_Handle *ah; char *quota_wan_in_str; char *quota_wan_out_str; + char *mode_str; + int c; - running = GNUNET_NO; - - addresses = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO); - GNUNET_assert (NULL != addresses); + ah = GNUNET_malloc (sizeof (struct GAS_Addresses_Handle)); + handle = ah; + handle->running = GNUNET_NO; + /* Initialize the system with configuration values */ if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", "a_wan_in_str)) { if (0 == strcmp(quota_wan_in_str, "unlimited") || - (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_in_str, &wan_quota_in))) - wan_quota_in = (UINT32_MAX) /10; + (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_in_str, &ah->wan_quota_in))) + ah->wan_quota_in = (UINT32_MAX) /10; GNUNET_free (quota_wan_in_str); quota_wan_in_str = NULL; } else - { - wan_quota_in = (UINT32_MAX) /10; - } + ah->wan_quota_in = (UINT32_MAX) /10; if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", "a_wan_out_str)) { if (0 == strcmp(quota_wan_out_str, "unlimited") || - (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_out_str, &wan_quota_out))) - wan_quota_out = (UINT32_MAX) /10; + (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_out_str, &ah->wan_quota_out))) + ah->wan_quota_out = (UINT32_MAX) /10; GNUNET_free (quota_wan_out_str); quota_wan_out_str = NULL; } else + ah->wan_quota_out = (UINT32_MAX) /10; + + /* Initialize the addresses database */ + ah->addresses = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO); + GNUNET_assert (NULL != ah->addresses); + + /* Figure out configured solution method */ + if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "ats", "MODE", &mode_str)) { - wan_quota_out = (UINT32_MAX) /10; + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "No ressource assignment method configured, using simplistic approch\n"); + ah->ats_mode = MODE_SIMPLISTIC; } - - mode = GNUNET_CONFIGURATION_get_value_yesno (cfg, "ats", "MLP"); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP mode %u", mode); - switch (mode) + else { - /* MLP = YES */ - case GNUNET_YES: -#if HAVE_LIBGLPK - ats_mode = MLP; - /* Init the MLP solver with default values */ - mlp = GAS_mlp_init (cfg, stats, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS); - if (NULL == mlp) + for (c = 0; c < strlen (mode_str); c++) + mode_str[c] = toupper (mode_str[c]); + if (0 == strcmp (mode_str, "SIMPLISTIC")) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP mode was configured, but libglpk is not installed, switching to simple mode\n"); - GNUNET_STATISTICS_update (GSA_stats, "MLP mode enabled", 0, GNUNET_NO); - break; + ah->ats_mode = MODE_SIMPLISTIC; + } + else if (0 == strcmp (mode_str, "MLP")) + { + ah->ats_mode = MODE_MLP; +#if !HAVE_LIBGLPK + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Assignment method `%s' configured, but GLPK is not availabe, please install \n", mode_str); + ah->ats_mode = MODE_SIMPLISTIC; +#endif } else { - GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 1, GNUNET_NO); - break; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid ressource assignment method `%s' configured, using simplistic approch\n", mode_str); + ah->ats_mode = MODE_SIMPLISTIC; } + GNUNET_free (mode_str); + } + /* Start configured solution method */ + switch (ah->ats_mode) + { + case MODE_MLP: + /* Init the MLP solver with default values */ +#if HAVE_LIBGLPK + ah->ats_mode = MODE_MLP; + ah->s_init = &GAS_mlp_init; + ah->s_update = &GAS_mlp_address_update; + ah->s_get = &GAS_mlp_get_preferred_address; + ah->s_pref = &GAS_mlp_address_change_preference; + ah->s_del = &GAS_mlp_address_delete; + ah->s_done = &GAS_mlp_done; #else - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MLP mode was configured, but libglpk is not installed, switching to simple mode"); - GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO); - ats_mode = SIMPLE; - break; + GNUNET_free (ah); + return NULL; #endif - /* MLP = NO */ - case GNUNET_NO: - GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO); - ats_mode = SIMPLE; break; - /* No configuration value */ - case GNUNET_SYSERR: - GNUNET_STATISTICS_update (GSA_stats, "MLP enabled", 0, GNUNET_NO); - ats_mode = SIMPLE; + case MODE_SIMPLISTIC: + /* Init the simplistic solver with default values */ + ah->ats_mode = MODE_SIMPLISTIC; + ah->s_init = &GAS_simplistic_init; + ah->s_update = &GAS_simplistic_address_update; + ah->s_get = &GAS_simplistic_get_preferred_address; + ah->s_pref = &GAS_simplistic_address_change_preference; + ah->s_del = &GAS_simplistic_address_delete; + ah->s_done = &GAS_simplistic_done; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started in %s mode\n", "SIMPLISTIC"); break; default: + return NULL; break; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started with %s mode\n", (SIMPLE == ats_mode) ? "SIMPLE" : "MLP"); - running = GNUNET_YES; + + GNUNET_assert (NULL != ah->s_init); + GNUNET_assert (NULL != ah->s_update); + GNUNET_assert (NULL != ah->s_get); + GNUNET_assert (NULL != ah->s_pref); + GNUNET_assert (NULL != ah->s_del); + GNUNET_assert (NULL != ah->s_done); + + ah->solver = ah->s_init (cfg, stats); + if (NULL == ah->solver) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to initialize MLP solver!\n"); + GNUNET_free (ah); + return NULL; + } + + /* up and running */ + ah->running = GNUNET_YES; + return ah; } @@ -1026,12 +1166,12 @@ free_address_it (void *cls, const struct GNUNET_HashCode * key, void *value) void GAS_addresses_destroy_all () { - if (GNUNET_NO == running) + if (GNUNET_NO == handle->running) return; - if (addresses != NULL) - GNUNET_CONTAINER_multihashmap_iterate (addresses, &free_address_it, NULL); - GNUNET_assert (active_addr_count == 0); + if (handle->addresses != NULL) + GNUNET_CONTAINER_multihashmap_iterate (handle->addresses, &free_address_it, NULL); + GNUNET_assert (handle->active_addr_count == 0); } @@ -1039,18 +1179,17 @@ GAS_addresses_destroy_all () * Shutdown address subsystem. */ void -GAS_addresses_done () +GAS_addresses_done (struct GAS_Addresses_Handle *handle) { + GNUNET_assert (NULL != handle); + GAS_addresses_destroy_all (); - running = GNUNET_NO; - GNUNET_CONTAINER_multihashmap_destroy (addresses); - addresses = NULL; -#if HAVE_LIBGLPK - if (ats_mode == MLP) - { - GAS_mlp_done (mlp); - } -#endif + handle->running = GNUNET_NO; + GNUNET_CONTAINER_multihashmap_destroy (handle->addresses); + handle->addresses = NULL; + GNUNET_free (handle); + /* Stop configured solution method */ + } struct PeerIteratorContext @@ -1081,7 +1220,8 @@ peer_it (void *cls, /** * Return all peers currently known to ATS * - * @param p_it the iterator to call for every peer + * @param p_it the iterator to call for every peer, callbach with id == NULL + * when done * @param p_it_cls the closure for the iterator */ void @@ -1090,20 +1230,20 @@ GAS_addresses_iterate_peers (GNUNET_ATS_Peer_Iterator p_it, void *p_it_cls) struct PeerIteratorContext ip_ctx; unsigned int size; - if (NULL == it) + if (NULL == p_it) return; - GNUNET_assert (NULL != addresses); + GNUNET_assert (NULL != handle->addresses); - size = GNUNET_CONTAINER_multihashmap_size(addresses); + size = GNUNET_CONTAINER_multihashmap_size(handle->addresses); if (0 != size) { - ip_ctx.it = it; - ip_ctx.it_cls = it_cls; + ip_ctx.it = p_it; + ip_ctx.it_cls = p_it_cls; ip_ctx.peers_returned = GNUNET_CONTAINER_multihashmap_create (size, GNUNET_NO); - GNUNET_CONTAINER_multihashmap_iterate (addresses, &peer_it, &ip_ctx); + GNUNET_CONTAINER_multihashmap_iterate (handle->addresses, &peer_it, &ip_ctx); GNUNET_CONTAINER_multihashmap_destroy (ip_ctx.peers_returned); } - it (it_cls, NULL); + p_it (p_it_cls, NULL); } struct PeerInfoIteratorContext @@ -1112,24 +1252,35 @@ struct PeerInfoIteratorContext void *it_cls; }; -int peerinfo_it (void *cls, - const struct GNUNET_HashCode * key, - void *value) + +static int +peerinfo_it (void *cls, + const struct GNUNET_HashCode * key, + void *value) { struct PeerInfoIteratorContext *pi_ctx = cls; struct ATS_Address *addr = (struct ATS_Address *) value; + struct GNUNET_ATS_Information *ats; + uint32_t ats_count; + + if (NULL != pi_ctx->it) + { + ats_count = assemble_ats_information (addr, &ats); - if ((NULL != pi_ctx->it) && (GNUNET_YES == addr->used)) pi_ctx->it (pi_ctx->it_cls, &addr->peer, addr->plugin, addr->addr, addr->addr_len, - addr->ats, addr->ats_count, + addr->active, + ats, ats_count, addr->assigned_bw_out, addr->assigned_bw_in); + GNUNET_free (ats); + } return GNUNET_YES; } + /** * Return all peers currently known to ATS * @@ -1143,16 +1294,18 @@ GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer, GNUNET_ATS_ struct PeerInfoIteratorContext pi_ctx; struct GNUNET_BANDWIDTH_Value32NBO zero_bw; GNUNET_assert (NULL != peer); - GNUNET_assert (NULL != addresses); + GNUNET_assert (NULL != handle->addresses); + if (NULL == pi_it) + return; /* does not make sense without callback */ zero_bw = GNUNET_BANDWIDTH_value_init (0); pi_ctx.it = pi_it; pi_ctx.it_cls = pi_it_cls; - GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, &peerinfo_it, &pi_ctx); + GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &peerinfo_it, &pi_ctx); if (NULL != pi_it) - pi_it (pi_it_cls, NULL, NULL, NULL, 0, NULL, 0, zero_bw, zero_bw); + pi_it (pi_it_cls, NULL, NULL, NULL, 0, GNUNET_NO, NULL, 0, zero_bw, zero_bw); }