X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fats%2Fgnunet-service-ats_addresses.c;h=b94a7165624726a85d3996ebb1efa54e6593662f;hb=e8bc9fe72894972f3280eed7cdb0e1994188ff38;hp=b836822709d0b3f02e2fb6b8d56d4ee6f2a851e2;hpb=59020e95cbee41e514c962c7383afa5157615f11;p=oweals%2Fgnunet.git diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c index b83682270..b94a71656 100644 --- a/src/ats/gnunet-service-ats_addresses.c +++ b/src/ats/gnunet-service-ats_addresses.c @@ -36,8 +36,6 @@ #endif #include "gnunet-service-ats_addresses_simplistic.h" -#define ATS_BLOCKING_DELTA GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100) - /** * Available ressource assignment modes @@ -62,39 +60,109 @@ enum ATS_Mode MODE_MLP }; +/** + * Handle for ATS address component + */ +struct GAS_Addresses_Suggestion_Requests +{ + struct GAS_Addresses_Suggestion_Requests *next; + struct GAS_Addresses_Suggestion_Requests *prev; + struct GNUNET_PeerIdentity id; +}; - - - +/** + * Handle for ATS address component + */ struct GAS_Addresses_Handle { + /** + * A multihashmap to store all addresses + */ struct GNUNET_CONTAINER_MultiHashMap *addresses; + /** + * Configure WAN quota in + */ unsigned long long wan_quota_in; + /** + * Configure WAN quota out + */ unsigned long long wan_quota_out; - unsigned int active_addr_count; - + /** + * Is ATS addresses running + */ int running; - + /** + * Configured ATS solver + */ int ats_mode; - /* Solver handle */ + + /** + * Solver handle + */ void *solver; + /** + * Address suggestion requests DLL head + */ + struct GAS_Addresses_Suggestion_Requests *r_head; + + /** + * Address suggestion requests DLL tail + */ + struct GAS_Addresses_Suggestion_Requests *r_tail; + /* Solver functions */ + + /** + * Initialize solver + */ GAS_solver_init s_init; - GAS_solver_done s_done; + + /** + * Add an address to the solver + */ + GAS_solver_address_add s_add; + + /** + * 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) +assemble_ats_information (const 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)); @@ -119,74 +187,59 @@ assemble_ats_information (struct ATS_Address *aa, struct GNUNET_ATS_Information 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, - 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->active, - ats, ats_count, aa->assigned_bw_out, - aa->assigned_bw_in); - GNUNET_free (ats); -} - -/** - * Update a bandwidth assignment for a peer. This trivial method currently - * simply assigns the same share to all active connections. - * - * @param cls unused - * @param key unused - * @param value the 'struct ATS_Address' - * @return GNUNET_OK (continue to iterate) - */ -static int -update_bw_simple_it (void *cls, const struct GNUNET_HashCode * key, void *value) -{ - struct ATS_Address *aa = value; - - if (GNUNET_YES != aa->active) - return GNUNET_OK; - GNUNET_assert (handle->active_addr_count > 0); - - - /* Simple method */ - 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); - - return GNUNET_OK; -} - - -/** - * Some (significant) input changed, recalculate bandwidth assignment - * for all peers. - */ -static void -recalculate_assigned_bw () +static unsigned int +disassemble_ats_information (const struct GNUNET_ATS_Information *src, + uint32_t ats_count, + struct ATS_Address *dest) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "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", handle->active_addr_count, - GNUNET_NO); - - GNUNET_CONTAINER_multihashmap_iterate (handle->addresses, &update_bw_simple_it, NULL); + int i; + int res = 0; + for (i = 0; i < ats_count; i++) + switch (ntohl (src[i].type)) + { + case GNUNET_ATS_UTILIZATION_UP: + dest->atsp_utilization_out.value__ = src[i].value; + res ++; + break; + case GNUNET_ATS_UTILIZATION_DOWN: + dest->atsp_utilization_in.value__ = src[i].value; + res ++; + break; + case GNUNET_ATS_QUALITY_NET_DELAY: + dest->atsp_latency.rel_value = ntohl (src[i].value); + res ++; + break; + case GNUNET_ATS_QUALITY_NET_DISTANCE: + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Old ATS type %u %u\n", dest->atsp_distance, ntohl (src[i].type)); + dest->atsp_distance = ntohl (src[i].value); + res ++; + break; + case GNUNET_ATS_COST_WAN: + dest->atsp_cost_wan = ntohl (src[i].value); + res ++; + break; + case GNUNET_ATS_COST_LAN: + dest->atsp_cost_lan = ntohl (src[i].value); + res ++; + break; + case GNUNET_ATS_COST_WLAN: + dest->atsp_cost_wlan = ntohl (src[i].value); + res ++; + break; + case GNUNET_ATS_NETWORK_TYPE: + dest->atsp_network_type = ntohl (src[i].value); + res ++; + break; + case GNUNET_ATS_ARRAY_TERMINATOR: + break; + default: + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Received unsupported ATS type %u\n", ntohl (src[i].type)); + GNUNET_break (0); + break; + } + return res; } /** @@ -196,7 +249,6 @@ recalculate_assigned_bw () static void free_address (struct ATS_Address *addr) { - GNUNET_free_non_null (addr->ats); GNUNET_free (addr->plugin); GNUNET_free (addr); } @@ -225,6 +277,10 @@ create_address (const struct GNUNET_PeerIdentity *peer, memcpy (&aa[1], plugin_addr, plugin_addr_len); aa->plugin = GNUNET_strdup (plugin_name); aa->session_id = session_id; + aa->active = GNUNET_NO; + aa->solver_information = NULL; + aa->assigned_bw_in = GNUNET_BANDWIDTH_value_init(0); + aa->assigned_bw_out = GNUNET_BANDWIDTH_value_init(0); return aa; } @@ -246,17 +302,7 @@ destroy_address (struct ATS_Address *addr) &addr->peer.hashPubKey, addr)); -#if HAVE_LIBGLPK - if (handle->ats_mode == MODE_MLP) - GAS_mlp_address_delete (handle->solver, handle->addresses, addr); -#endif - - if (GNUNET_YES == addr->active) - { - handle->active_addr_count--; - addr->active = GNUNET_NO; - ret = GNUNET_YES; - } + handle->s_del (handle->solver, handle->addresses, addr); free_address (addr); return ret; } @@ -279,11 +325,6 @@ compare_address_it (void *cls, const struct GNUNET_HashCode * key, void *value) struct CompareAddressContext *cac = cls; struct ATS_Address *aa = value; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Comparing peer %4s: address length %u session %u <-> address length %u session %u\n", - GNUNET_h2s (key), - aa->addr_len, aa->session_id, - cac->search->addr_len, cac->search->session_id); - /* Find an matching exact address: * * Compare by: @@ -365,12 +406,6 @@ find_address (const struct GNUNET_PeerIdentity *peer, GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &compare_address_it, &cac); -#if 0 - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Found exact address: %s base address: %s\n", - (cac.exact_address != NULL) ? "YES" : "NO", - (cac.base_address != NULL) ? "YES" : "NO"); -#endif if (cac.exact_address == NULL) return cac.base_address; return cac.exact_address; @@ -392,11 +427,6 @@ lookup_address (const struct GNUNET_PeerIdentity *peer, plugin_addr, plugin_addr_len, session_id); - aa->mlp_information = NULL; - aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information)); - aa->ats_count = atsi_count; - memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information)); - /* Get existing address or address with session == 0 */ old = find_address (peer, aa); free_address (aa); @@ -412,47 +442,6 @@ lookup_address (const struct GNUNET_PeerIdentity *peer, } -static int -compare_address_session_it (void *cls, const struct GNUNET_HashCode * key, void *value) -{ - struct CompareAddressContext *cac = cls; - struct ATS_Address *aa = value; - - if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin))) - { - if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == cac->search->session_id)) - { - cac->exact_address = aa; - return GNUNET_NO; - } - } - return GNUNET_YES; -} - - -/** - * Find an existing equivalent address record. - * Compares by peer identity and network address AND by session ID - * (one of the two must match). - * - * @param peer peer to lookup addresses for - * @param addr existing address record - * @return existing address record, NULL for none - */ -static struct ATS_Address * -find_exact_address (const struct GNUNET_PeerIdentity *peer, - const struct ATS_Address *addr) -{ - struct CompareAddressContext cac; - - cac.exact_address = NULL; - cac.search = addr; - GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, - &compare_address_session_it, &cac); - return cac.exact_address; -} - - void GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, @@ -462,6 +451,12 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, { struct ATS_Address *aa; struct ATS_Address *old; + unsigned int ats_res; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s'\n", + "ADDRESS ADD", + GNUNET_i2s (peer)); if (GNUNET_NO == handle->running) return; @@ -472,11 +467,12 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, plugin_name, plugin_addr, plugin_addr_len, session_id); - - aa->mlp_information = NULL; - aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information)); - aa->ats_count = atsi_count; - memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information)); + if (atsi_count != (ats_res = disassemble_ats_information(atsi, atsi_count, aa))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "While adding address: had %u ATS elements to add, could only add %u\n", + atsi_count, ats_res); + } /* Get existing address or address with session == 0 */ old = find_address (peer, aa); @@ -489,31 +485,36 @@ GAS_addresses_add (const struct GNUNET_PeerIdentity *peer, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new address for peer `%s' session id %u, %p\n", GNUNET_i2s (peer), session_id, aa); + /* Tell solver about new address */ + handle->s_add (handle->solver, handle->addresses, aa); return; } + GNUNET_free (aa->plugin); + GNUNET_free (aa); - if (old->session_id == 0) + if (old->session_id != 0) { - /* We have a base address with out an session, update this address */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Updated existing address for peer `%s' %p with new session %u\n", - GNUNET_i2s (peer), old, session_id); - GNUNET_free_non_null (old->ats); - old->session_id = session_id; - old->ats = NULL; - old->ats_count = 0; - old->ats = aa->ats; - old->ats_count = aa->ats_count; - GNUNET_free (aa->plugin); - GNUNET_free (aa); - return; + /* This address and session is already existing */ + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Added already existing address for peer `%s' `%s' %p with new session %u\n", + GNUNET_i2s (peer), plugin_name, session_id); + GNUNET_break (0); + return; } - /* This address and session is already existing */ - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Added already existing address for peer `%s' `%s' %p with new session %u\n", - GNUNET_i2s (peer), plugin_name, session_id); - GNUNET_break (0); + /* We have an address without an session, update this address */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Updated existing address for peer `%s' %p with new session %u\n", + GNUNET_i2s (peer), old, session_id); + old->session_id = session_id; + if (atsi_count != (ats_res = disassemble_ats_information(atsi, atsi_count, old))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "While updating address: had %u ATS elements to add, could only add %u\n", + atsi_count, ats_res); + } + + handle->s_update (handle->solver, handle->addresses, old); } @@ -524,8 +525,8 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer, const struct GNUNET_ATS_Information *atsi, uint32_t atsi_count) { - struct ATS_Address *old; - uint32_t i; + struct ATS_Address *aa; + uint32_t ats_res; if (GNUNET_NO == handle->running) return; @@ -533,9 +534,9 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer, GNUNET_assert (NULL != handle->addresses); /* Get existing address */ - old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len, + aa = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id, atsi, atsi_count); - if (old == NULL) + if (aa == NULL) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Tried to update unknown address for peer `%s' `%s' session id %u\n", GNUNET_i2s (peer), plugin_name, session_id); @@ -543,54 +544,23 @@ GAS_addresses_update (const struct GNUNET_PeerIdentity *peer, return; } - for (i = 0; i < atsi_count; i++) - switch (ntohl (atsi[i].type)) - { - case GNUNET_ATS_UTILIZATION_UP: - old->atsp_utilization_out.value__ = atsi[i].value; - break; - case GNUNET_ATS_UTILIZATION_DOWN: - old->atsp_utilization_in.value__ = atsi[i].value; - break; - case GNUNET_ATS_QUALITY_NET_DELAY: - old->atsp_latency.rel_value = ntohl (atsi[i].value); - break; - case GNUNET_ATS_QUALITY_NET_DISTANCE: - old->atsp_distance = ntohl (atsi[i].value); - break; - case GNUNET_ATS_COST_WAN: - old->atsp_cost_wan = ntohl (atsi[i].value); - break; - case GNUNET_ATS_COST_LAN: - old->atsp_cost_lan = ntohl (atsi[i].value); - break; - case GNUNET_ATS_COST_WLAN: - old->atsp_cost_wlan = ntohl (atsi[i].value); - break; - case GNUNET_ATS_NETWORK_TYPE: - old->atsp_network_type = ntohl (atsi[i].value); - break; - - default: - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Received unsupported ATS type %u\n", ntohl (atsi[i].type)); - GNUNET_break (0); - break; - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s' address \n", + "ADDRESS UPDATE", + GNUNET_i2s (peer), aa); - /* Tell solver about update */ - switch (handle->ats_mode) + if (atsi_count != (ats_res = disassemble_ats_information (atsi, atsi_count, aa))) { - case MODE_MLP: - GAS_mlp_address_update (handle->solver, handle->addresses, old); - break; - case MODE_SIMPLISTIC: - GAS_simplistic_address_update (handle->solver, handle->addresses, old); - break; - default: - GNUNET_break (0); - break; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "While adding address: had %u ATS elements to add, could only add %u\n", + atsi_count, ats_res); } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Updated %u ATS elements for address %p\n", + ats_res, aa); + + /* Tell solver about update */ + handle->s_update (handle->solver, handle->addresses, aa); } @@ -625,8 +595,8 @@ destroy_by_session_id (void *cls, const struct GNUNET_HashCode * key, void *valu "Deleting address for peer `%s': `%s' %u\n", GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id); - if (GNUNET_YES == destroy_address (aa)) - recalculate_assigned_bw (); + destroy_address (aa); + // FIXME if (GNUNET_YES == destroy_address (aa))recalculate_assigned_bw (); return GNUNET_OK; } /* session != 0, just remove session */ @@ -643,8 +613,7 @@ destroy_by_session_id (void *cls, const struct GNUNET_HashCode * key, void *valu if (GNUNET_YES == aa->active) { aa->active = GNUNET_NO; - handle->active_addr_count--; - recalculate_assigned_bw (); + //FIXME recalculate_assigned_bw (); } /* session == 0 and addrlen == 0 : destroy address */ @@ -676,6 +645,11 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, struct ATS_Address *aa; struct ATS_Address *old; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s'\n", + "ADDRESS DESTROY", + GNUNET_i2s (peer)); + if (GNUNET_NO == handle->running) return; @@ -689,119 +663,26 @@ GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer, return; } - GNUNET_break (0 < strlen (plugin_name)); aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id); - GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &destroy_by_session_id, aa); - free_address (aa); } -/** - * Find a "good" address to use for a peer. If we already have an existing - * address, we stick to it. Otherwise, we pick by lowest distance and then - * by lowest latency. - * - * @param cls the 'struct ATS_Address**' where we store the result - * @param key unused - * @param value another 'struct ATS_Address*' to consider using - * @return GNUNET_OK (continue to iterate) - */ -static int -find_address_it (void *cls, const struct GNUNET_HashCode * key, void *value) -{ - struct ATS_Address **ap = cls; - struct ATS_Address *aa = (struct ATS_Address *) value; - struct ATS_Address *ab = *ap; - struct GNUNET_TIME_Absolute now; - - now = GNUNET_TIME_absolute_get(); - - if (aa->blocked_until.abs_value == GNUNET_TIME_absolute_max (now, aa->blocked_until).abs_value) - { - /* This address is blocked for suggestion */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Address %p blocked for suggestion for %llu ms \n", - aa, - GNUNET_TIME_absolute_get_difference(now, aa->blocked_until).rel_value); - return GNUNET_OK; - } - - aa->block_interval = GNUNET_TIME_relative_add (aa->block_interval, ATS_BLOCKING_DELTA); - aa->blocked_until = GNUNET_TIME_absolute_add (now, aa->block_interval); - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Address %p ready for suggestion, block interval now %llu \n", aa, aa->block_interval); - - /* FIXME this is a hack */ - - - if (NULL != ab) - { - if ((0 == strcmp (ab->plugin, "tcp")) && - (0 == strcmp (aa->plugin, "tcp"))) - { - if ((0 != ab->addr_len) && - (0 == aa->addr_len)) - { - /* saved address was an outbound address, but we have an inbound address */ - *ap = aa; - return GNUNET_OK; - } - if (0 == ab->addr_len) - { - /* saved address was an inbound address, so do not overwrite */ - return GNUNET_OK; - } - } - } - /* FIXME end of hack */ - - if (NULL == ab) - { - *ap = aa; - return GNUNET_OK; - } - if ((ntohl (ab->assigned_bw_in.value__) == 0) && - (ntohl (aa->assigned_bw_in.value__) > 0)) - { - /* stick to existing connection */ - *ap = aa; - return GNUNET_OK; - } - if (ab->atsp_distance > aa->atsp_distance) - { - /* user shorter distance */ - *ap = aa; - return GNUNET_OK; - } - if (ab->atsp_latency.rel_value > aa->atsp_latency.rel_value) - { - /* user lower latency */ - *ap = aa; - return GNUNET_OK; - } - /* don't care */ - return GNUNET_OK; -} - - int GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer, const char *plugin_name, const void *plugin_addr, size_t plugin_addr_len, uint32_t session_id, int in_use) { -#if DEBUG_ATS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received `%s' message for peer `%s': %i\n", "ADDRESS_IN_USE", - GNUNET_i2s (peer), in_use); -#endif - struct ATS_Address *old; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s'\n", + "ADDRESS IN USE", + GNUNET_i2s (peer)); + if (GNUNET_NO == handle->running) return GNUNET_SYSERR; @@ -829,119 +710,108 @@ GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer, old->used = in_use; /* Tell solver about update */ - switch (handle->ats_mode) - { - case MODE_MLP: - GAS_mlp_address_update (handle->solver, handle->addresses, old); - break; - case MODE_SIMPLISTIC: - GAS_simplistic_address_update (handle->solver, handle->addresses, old); - break; - default: - GNUNET_break (0); - break; - } + handle->s_update (handle->solver, handle->addresses, old); + return GNUNET_OK; } -static void -request_address_mlp (const struct GNUNET_PeerIdentity *peer) +/** + * Cancel address suggestions for a peer + * + * @param peer the respective peer + */ +void +GAS_addresses_request_address_cancel (const struct GNUNET_PeerIdentity *peer) { - struct ATS_Address *aa; - aa = NULL; - -#if HAVE_GLPK - /* Get preferred address from MODE_MLP */ - struct ATS_PreferedAddress * paddr = NULL; - paddr = GAS_mlp_get_preferred_address (mlp, addresses, peer); - aa = paddr->address; - aa->assigned_bw_out = GNUNET_BANDWIDTH_value_init(paddr->bandwidth_out); - /* FIXME use bw in value */ - paddr->bandwidth_in = paddr->bandwidth_out; - aa->assigned_bw_in = GNUNET_BANDWIDTH_value_init (paddr->bandwidth_in); - GNUNET_free (paddr); -#endif + struct GAS_Addresses_Suggestion_Requests *cur = handle->r_head; - if (aa == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "Cannot suggest address for peer `%s'\n", GNUNET_i2s (peer)); - return; - } - if (aa->active == GNUNET_NO) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received request: `%s' for peer %s\n", "request_address_cancel", GNUNET_i2s (peer)); + + while (NULL != cur) { - aa->active = GNUNET_YES; - handle->active_addr_count++; - send_bw_notification (aa); + if (0 == memcmp (peer, &cur->id, sizeof (cur->id))) + break; /* found */ + cur = cur->next; } - else + + if (NULL == cur) { - /* just to be sure... */ - GAS_scheduling_transmit_address_suggestion (peer, aa->plugin, aa->addr, - aa->addr_len, aa->session_id, - aa->ats, aa->ats_count, - aa->assigned_bw_out, - aa->assigned_bw_in); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "No address requests pending for peer `%s', cannot remove!\n", GNUNET_i2s (peer)); + return; } - + GAS_addresses_handle_backoff_reset (peer); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removed request pending for peer `%s\n", GNUNET_i2s (peer)); + GNUNET_CONTAINER_DLL_remove (handle->r_head, handle->r_tail, cur); + GNUNET_free (cur); } -static void -request_address_simple (const struct GNUNET_PeerIdentity *peer) +/** + * Add an address suggestions for a peer + * + * @param peer the respective peer + */ +void +GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer) { + struct GAS_Addresses_Suggestion_Requests *cur = handle->r_head; struct ATS_Address *aa; - aa = NULL; + struct GNUNET_ATS_Information *ats; + unsigned int ats_count; - /* Get address with: stick to current address, lower distance, lower latency */ - GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, - &find_address_it, &aa); - if (aa == NULL) + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s'\n", + "REQUEST ADDRESS", + GNUNET_i2s (peer)); + + if (GNUNET_NO == handle->running) + return; + while (NULL != cur) + { + if (0 == memcmp (peer, &cur->id, sizeof (cur->id))) + break; /* already suggesting */ + cur = cur->next; + } + if (NULL == cur) + { + cur = GNUNET_malloc (sizeof (struct GAS_Addresses_Suggestion_Requests)); + cur->id = (*peer); + GNUNET_CONTAINER_DLL_insert (handle->r_head, handle->r_tail, cur); + } + + /* Get prefered address from solver */ + aa = (struct ATS_Address *) handle->s_get (handle->solver, handle->addresses, peer); + if (NULL == aa) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cannot suggest address for peer `%s'\n", GNUNET_i2s (peer)); return; } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Suggesting address %p for peer `%s'\n", aa, GNUNET_i2s (peer)); - if (aa->active == GNUNET_NO) - { - aa->active = GNUNET_YES; - handle->active_addr_count++; - if (handle->ats_mode == MODE_SIMPLISTIC) - { - recalculate_assigned_bw (); - } - } - else - { - /* just to be sure... */ - GAS_scheduling_transmit_address_suggestion (peer, aa->plugin, aa->addr, - aa->addr_len, aa->session_id, - aa->ats, aa->ats_count, - aa->assigned_bw_out, - aa->assigned_bw_in); - } -} + ats_count = assemble_ats_information (aa, &ats); + GAS_scheduling_transmit_address_suggestion (peer, + aa->plugin, + aa->addr, aa->addr_len, + aa->session_id, + ats, ats_count, + aa->assigned_bw_out, + aa->assigned_bw_in); + aa->block_interval = GNUNET_TIME_relative_add (aa->block_interval, ATS_BLOCKING_DELTA); + aa->blocked_until = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(), aa->block_interval); -void -GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer) -{ - if (GNUNET_NO == handle->running) - return; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Address %p ready for suggestion, block interval now %llu \n", + aa, aa->block_interval); - if (handle->ats_mode == MODE_SIMPLISTIC) - { - request_address_simple (peer); - } - if (handle->ats_mode == MODE_MLP) - { - request_address_mlp(peer); - } + GNUNET_free (ats); } @@ -951,7 +821,8 @@ reset_address_it (void *cls, const struct GNUNET_HashCode * key, void *value) struct ATS_Address *aa = value; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Resetting interval for peer `%s' address %p from %llu to 0\n", GNUNET_i2s (&aa->peer), aa, aa->block_interval); + "Resetting interval for peer `%s' address %p from %llu to 0\n", + GNUNET_i2s (&aa->peer), aa, aa->block_interval); aa->blocked_until = GNUNET_TIME_UNIT_ZERO_ABS; aa->block_interval = GNUNET_TIME_UNIT_ZERO; @@ -962,6 +833,11 @@ reset_address_it (void *cls, const struct GNUNET_HashCode * key, void *value) void GAS_addresses_handle_backoff_reset (const struct GNUNET_PeerIdentity *peer) { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s'\n", + "RESET BACKOFF", + GNUNET_i2s (peer)); + GNUNET_break (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple (handle->addresses, &peer->hashPubKey, &reset_address_it, @@ -969,34 +845,141 @@ GAS_addresses_handle_backoff_reset (const struct GNUNET_PeerIdentity *peer) } - -// 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) { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received `%s' for peer `%s'\n", + "CHANGE PREFERENCE", + GNUNET_i2s (peer)); + if (GNUNET_NO == handle->running) return; - /* Tell solver about update */ - switch (handle->ats_mode) + handle->s_pref (handle->solver, peer, kind, score); +} + +static unsigned int +load_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned long long *out_dest, unsigned long long *in_dest, int dest_length) +{ + int quotas[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType; + char * entry_in = NULL; + char * entry_out = NULL; + char * quota_out_str; + char * quota_in_str; + int c; + + for (c = 0; (c < GNUNET_ATS_NetworkTypeCount) && (c < dest_length); c++) { - case MODE_MLP: - GAS_mlp_address_change_preference (handle->solver, peer, kind, score); - break; - case MODE_SIMPLISTIC: - GAS_simplistic_address_change_preference (handle->solver, peer, kind, score); - break; - default: - GNUNET_break (0); - break; + in_dest[c] = 0; + out_dest[c] = 0; + switch (quotas[c]) { + case GNUNET_ATS_NET_UNSPECIFIED: + entry_out = "UNSPECIFIED_QUOTA_OUT"; + entry_in = "UNSPECIFIED_QUOTA_IN"; + break; + case GNUNET_ATS_NET_LOOPBACK: + entry_out = "LOOPBACK_QUOTA_OUT"; + entry_in = "LOOPBACK_QUOTA_IN"; + break; + case GNUNET_ATS_NET_LAN: + entry_out = "LAN_QUOTA_OUT"; + entry_in = "LAN_QUOTA_IN"; + break; + case GNUNET_ATS_NET_WAN: + entry_out = "WAN_QUOTA_OUT"; + entry_in = "WAN_QUOTA_IN"; + break; + case GNUNET_ATS_NET_WLAN: + entry_out = "WLAN_QUOTA_OUT"; + entry_in = "WLAN_QUOTA_IN"; + break; + default: + break; + } + + if ((entry_in == NULL) || (entry_out == NULL)) + continue; + + /* quota out */ + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, "a_out_str)) + { + if (0 == strcmp(quota_out_str, BIG_M_STRING) || + (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, &out_dest[c]))) + out_dest[c] = UINT32_MAX; + + GNUNET_free (quota_out_str); + quota_out_str = NULL; + } + else if (GNUNET_ATS_NET_UNSPECIFIED == quotas[c]) + out_dest[c] = UINT32_MAX; + else + out_dest[c] = UINT32_MAX; + + /* quota in */ + if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, "a_in_str)) + { + if (0 == strcmp(quota_in_str, BIG_M_STRING) || + (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, &in_dest[c]))) + in_dest[c] = UINT32_MAX; + + GNUNET_free (quota_in_str); + quota_in_str = NULL; + } + else if (GNUNET_ATS_NET_UNSPECIFIED == quotas[c]) + { + in_dest[c] = UINT32_MAX; + } + else + { + in_dest[c] = UINT32_MAX; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loaded quota: %s %u, %s %u\n", entry_in, in_dest[c], entry_out, out_dest[c]); + } + return GNUNET_ATS_NetworkTypeCount; } +static void +bandwidth_changed_cb (struct ATS_Address *address) +{ + struct GAS_Addresses_Suggestion_Requests *cur; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bandwidth assignment changed for peer %s \n", GNUNET_i2s(&address->peer)); + struct GNUNET_ATS_Information *ats; + unsigned int ats_count; + + cur = handle->r_head; + while (NULL != cur) + { + if (0 == memcmp (&address->peer, &cur->id, sizeof (cur->id))) + break; /* we have an address request pending*/ + cur = cur->next; + } + if (NULL == cur) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Nobody is interested in peer `%s' :(\n",GNUNET_i2s (&address->peer)); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending bandwidth update for peer `%s'\n",GNUNET_i2s (&address->peer)); + + ats_count = assemble_ats_information (address, &ats); + GAS_scheduling_transmit_address_suggestion (&address->peer, + address->plugin, + address->addr, address->addr_len, + address->session_id, + ats, ats_count, + address->assigned_bw_out, + address->assigned_bw_in); + GNUNET_free (ats); +} + /** * Initialize address subsystem. @@ -1009,8 +992,10 @@ GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_STATISTICS_Handle *stats) { struct GAS_Addresses_Handle *ah; - char *quota_wan_in_str; - char *quota_wan_out_str; + int quotas[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType; + unsigned long long quotas_in[GNUNET_ATS_NetworkTypeCount]; + unsigned long long quotas_out[GNUNET_ATS_NetworkTypeCount]; + int quota_count; char *mode_str; int c; @@ -1018,31 +1003,6 @@ GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg, 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, &ah->wan_quota_in))) - ah->wan_quota_in = (UINT32_MAX) /10; - - GNUNET_free (quota_wan_in_str); - quota_wan_in_str = NULL; - } - else - 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, &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); @@ -1084,6 +1044,9 @@ GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg, #if HAVE_LIBGLPK ah->ats_mode = MODE_MLP; ah->s_init = &GAS_mlp_init; + ah->s_add = &GAS_mlp_address_add; + 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; @@ -1096,6 +1059,9 @@ GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg, /* Init the simplistic solver with default values */ ah->ats_mode = MODE_SIMPLISTIC; ah->s_init = &GAS_simplistic_init; + ah->s_add = &GAS_simplistic_address_add; + 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; @@ -1107,14 +1073,19 @@ GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg, } GNUNET_assert (NULL != ah->s_init); + GNUNET_assert (NULL != ah->s_add); + 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); + quota_count = load_quotas(cfg, quotas_in, quotas_out, GNUNET_ATS_NetworkTypeCount); + + ah->solver = ah->s_init (cfg, stats, quotas, quotas_in, quotas_out, quota_count, &bandwidth_changed_cb); if (NULL == ah->solver) { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to initialize MLP solver!\n"); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to initialize solver!\n"); GNUNET_free (ah); return NULL; } @@ -1151,7 +1122,6 @@ GAS_addresses_destroy_all () if (handle->addresses != NULL) GNUNET_CONTAINER_multihashmap_iterate (handle->addresses, &free_address_it, NULL); - GNUNET_assert (handle->active_addr_count == 0); } @@ -1161,12 +1131,21 @@ GAS_addresses_destroy_all () void GAS_addresses_done (struct GAS_Addresses_Handle *handle) { - GNUNET_assert (NULL != handle); + struct GAS_Addresses_Suggestion_Requests *cur; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Shutting down addresses\n"); + GNUNET_assert (NULL != handle); GAS_addresses_destroy_all (); handle->running = GNUNET_NO; GNUNET_CONTAINER_multihashmap_destroy (handle->addresses); handle->addresses = NULL; + while (NULL != (cur = handle->r_head)) + { + GNUNET_CONTAINER_DLL_remove (handle->r_head, handle->r_tail, cur); + GNUNET_free (cur); + } + handle->s_done (handle->solver); GNUNET_free (handle); /* Stop configured solution method */