X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fats%2Fplugin_ats_proportional.c;h=9309bc2ea799df575b99b5884aea081cd2ab8552;hb=7c8c596991f6397ec3ca1911638acb2de721c7a7;hp=4a9dbd3ce5981553a2c4e05058516acbbcaa8bad;hpb=6468625abca41bd7ded392bd46aba352a8643721;p=oweals%2Fgnunet.git diff --git a/src/ats/plugin_ats_proportional.c b/src/ats/plugin_ats_proportional.c index 4a9dbd3ce..9309bc2ea 100644 --- a/src/ats/plugin_ats_proportional.c +++ b/src/ats/plugin_ats_proportional.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - Copyright (C) 2011-2015 Christian Grothoff (and other contributing authors) + Copyright (C) 2011-2015 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -14,10 +14,9 @@ You should have received a copy of the GNU General Public License along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ - /** * @file ats/plugin_ats_proportional.c * @brief ATS proportional solver @@ -26,193 +25,28 @@ */ #include "platform.h" #include "gnunet_statistics_service.h" -#include "gnunet_ats_plugin.h" #include "gnunet_ats_service.h" +#include "gnunet_ats_plugin.h" #include "gnunet-service-ats_addresses.h" -#define PROP_STABILITY_FACTOR 1.25 - - #define LOG(kind,...) GNUNET_log_from (kind, "ats-proportional",__VA_ARGS__) - /** - * - * NOTE: Do not change this documentation. This documentation is based - * on gnunet.org:/vcs/fsnsg/ats-paper.git/tech-doku/ats-tech-guide.tex - * use build_txt.sh to generate plaintext output - * - * ATS addresses : proportional solver - * - * The proportional solver ("proportional") distributes the available - * bandwidth fair over all the addresses influenced by the - * preference values. For each available network type an in- and - * outbound quota is configured and the bandwidth available in - * these networks is distributed over the addresses. The solver - * first assigns every addresses the minimum amount of bandwidth - * #GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT and then distributes the - * remaining bandwidth available according to the preference - * values. For each peer only a single address gets bandwidth - * assigned and only one address marked as active. The most - * important functionality for the solver is implemented in: * - * find_address_it is an hashmap iterator returning the prefered - * address for an peer * update_quota_per_network distributes - * available bandwidth for a network over active addresses - * - * Changes to addresses automatically have an impact on the the - * bandwidth assigned to other addresses in the same network since - * the solver distributes the remaining bandwidth over the - * addresses in the network. When changes to the addresses occur, - * the solver first performs the changes, like adding or deleting - * addresses, and then updates bandwidth assignment for the - * affected network. Bandwidth assignment is only recalculated on - * demand when an address is requested by a client for a peer or - * when the addresses available have changed or an address changed - * the network it is located in. When the bandwidth assignment has - * changed the callback is called with the new bandwidth - * assignments. The bandwidth distribution for a network is - * recalculated due to: * address suggestion requests * address - * deletions * address switching networks during address update * - * preference changes - * - * 3.1 Data structures used - * - * For each ATS network (e.g. WAN, LAN, loopback) a struct Network - * is used to specify network related information as total adresses - * and active addresses in this network and the configured in- and - * outbound quota. Each network also contains a list of addresses - * added to the solver located in this network. The proportional - * solver uses the addresses' solver_information field to store the - * proportional network it belongs to for each address. - * - * 3.2 Initializing - * - * When the proportional solver is initialized the solver creates a - * new solver handle and initializes the network structures with - * the quotas passed from addresses and returns the handle solver. - * - * 3.3 Adding an address - * - * When a new address is added to the solver using s_add, a lookup - * for the network for this address is done and the address is - * enqueued in in the linked list of the network. - * - * 3.4 Updating an address - * - * The main purpose of address updates is to update the ATS - * information for addresse selection. Important for the proportional - * solver is when an address switches network it is located - * in. This is common because addresses added by transport's - * validation mechanism are commonly located in - * #GNUNET_ATS_NET_UNSPECIFIED. Addresses in validation are located - * in this network type and only if a connection is successful on - * return of payload data transport switches to the real network - * the address is located in. When an address changes networks it - * is first of all removed from the old network using the solver - * API function #GAS_proportional_address_delete() and the network in - * the address struct is updated. A lookup for the respective new - * proportional network is done and stored in the addresse's - * solver_information field. Next the address is re-added to the - * solver using the solver API function - * #GAS_proportional_address_add(). If the address was marked as in - * active, the solver checks if bandwidth is available in the - * network and if yes sets the address to active and updates the - * bandwidth distribution in this network. If no bandwidth is - * available it sets the bandwidth for this address to 0 and tries - * to suggest an alternative address. If an alternative address was - * found, addresses' callback is called for this address. - * - * 3.5 Deleting an address - * - * When an address is removed from the solver, it removes the - * respective address from the network and if the address was - * marked as active, it updates the bandwidth distribution for this - * network. - * - * 3.6 Requesting addresses - * - * When an address is requested for a peer the solver performs a - * lookup for the peer entry in addresses address hashmap and - * selects the best address. The selection of the most suitable - * address is done in the find_address_it hashmap iterator - * described in detail in section 3.7. If no address is returned, - * no address can be suggested at the moment. If the address - * returned is marked as active, the solver can return this - * address. If the address is not marked as active, the solver - * checks if another address belongign to this peer is marked as - * active and marks the address as inactive, updates the bandwidth - * for this address to 0, call the bandwidth changed callback for - * this address due to the change and updates quota assignment for - * the addresse's network. the now in-active address is belonging - * to. The solver marks the new address as active and updates the - * bandwidth assignment for this network. - * - * 3.7 Choosing addresses - * - * Choosing the best possible address for suggestion is done by - * iterating over all addresses of a peer stored in addresses' - * hashmap and using the hashmap iterator find_address_it to select - * the best available address. Several checks are done when an - * address is selected. First if this address is currently blocked - * by addresses from being suggested. An address is blocked for the - * duration of #ATS_BLOCKING_DELTA when it is suggested to - * transport. Next it is checked if at least - * #GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT bytes bandwidth is available - * in the addresse's network, because suggesting an address without - * bandwidth does not make sense. This also ensures that all active - * addresses in this network get at least the minimum amount of - * bandwidth assigned. In the next step the solver ensures that for - * tcp connections inbound connections are prefered over outbound - * connections. In the next stet the solver ensures that - * connections are prefered in the following order: * connections - * are already established and have bandwidth assigned * - * connections with a shorter distance * connectes have a shorter - * latency - * - * 3.8 Changing preferences - * - * 3.9 Shutdown - * - * During shutdown all network entries and aging processes are - * destroyed and freed. - * - * - * OLD DOCUMENTATION - * - * This solver assigns in and outbound bandwidth equally for all - * addresses in specific network type (WAN, LAN) based on configured - * in and outbound quota for this network. - * - * The solver is notified by addresses about changes to the addresses - * and recalculates the bandwith assigned if required. The solver - * notifies addresses by calling the GAS_bandwidth_changed_cb - * callback. - * - * - Initialization - * - * - * - * - * For each peer only a single is selected and marked as "active" in the address - * struct. - * - * E.g.: - * - * You have the networks WAN and LAN and quotas - * WAN_TOTAL_IN, WAN_TOTAL_OUT - * LAN_TOTAL_IN, LAN_TOTAL_OUT - * - * If you have x addresses in the network segment LAN, the quotas are - * QUOTA_PER_ADDRESS = LAN_TOTAL_OUT / x - * - * Quotas are automatically recalculated and reported back when addresses are - * - requested - * + * How much do we value stability over adaptation by default. A low + * value (close to 1.0) means we adapt as soon as possible, a larger + * value means that we have to have the respective factor of an + * advantage (or delay) before we adapt and sacrifice stability. */ +#define PROP_STABILITY_FACTOR 1.25 + /** - * Default value to assume for the proportionality factor, - * if none is given in the configuration. + * Default value to assume for the proportionality factor, if none is + * given in the configuration. This factor determines how strong the + * bandwidth allocation will orient itself on the application + * preferences. A lower factor means a more balanced bandwidth + * distribution while a larger number means a distribution more in + * line with application (bandwidth) preferences. */ #define PROPORTIONALITY_FACTOR 2.0 @@ -364,10 +198,6 @@ struct GAS_PROPORTIONAL_Handle */ unsigned int active_addresses; - /** - * Number of networks in @a network_entries - */ - unsigned int network_count; }; @@ -385,7 +215,7 @@ is_bandwidth_available_in_network (struct Network *net, unsigned int na; uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__); - GNUNET_assert (net->active_addresses + extra >= 0); + GNUNET_assert (((int)net->active_addresses) + extra >= 0); na = net->active_addresses + extra; if (0 == na) return GNUNET_YES; @@ -422,33 +252,29 @@ all_require_connectivity (struct GAS_PROPORTIONAL_Handle *s, /** - * Update bandwidth assigned to peers in this network + * Update bandwidth assigned to peers in this network. The basic idea + * is to assign every peer in the network the minimum bandwidth, and + * then distribute the remaining bandwidth proportional to application + * preferences. * * @param s the solver handle * @param net the network type to update - * this address */ static void distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s, struct Network *net) { + const uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__); struct AddressWrapper *aw; - unsigned long long remaining_quota_in = 0; - unsigned long long quota_out_used = 0; - unsigned long long remaining_quota_out = 0; - unsigned long long quota_in_used = 0; - int count_addresses; - uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__); - double relative_peer_prefence; - double sum_relative_peer_prefences; /* Important: has to be double not float due to precision */ - double cur_pref; /* Important: has to be double not float due to precision */ + unsigned long long remaining_quota_in; + unsigned long long quota_out_used; + unsigned long long remaining_quota_out; + unsigned long long quota_in_used; + unsigned int count_addresses; + double sum_relative_peer_prefences; double peer_weight; double total_weight; - const double *peer_relative_prefs = NULL; /* Important: has to be double not float due to precision */ - - uint32_t assigned_quota_in = 0; - uint32_t assigned_quota_out = 0; - + const double *peer_relative_prefs; LOG (GNUNET_ERROR_TYPE_INFO, "Recalculate quota for network type `%s' for %u addresses (in/out): %llu/%llu \n", @@ -460,11 +286,7 @@ distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s, if (0 == net->active_addresses) return; /* no addresses to update */ - /* Idea: - * Assign every peer in network minimum Bandwidth - * Distribute remaining bandwidth proportional to preferences. - */ - + /* sanity checks */ if ((net->active_addresses * min_bw) > net->total_quota_in) { GNUNET_break(0); @@ -476,117 +298,88 @@ distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s, return; } - remaining_quota_in = net->total_quota_in - (net->active_addresses * min_bw); - remaining_quota_out = net->total_quota_out - (net->active_addresses * min_bw); - LOG(GNUNET_ERROR_TYPE_DEBUG, "Remaining bandwidth : (in/out): %llu/%llu \n", - remaining_quota_in, remaining_quota_out); + /* Calculate sum of relative preference for active addresses in this + network */ sum_relative_peer_prefences = 0.0; - - /* Calculate sum of relative preference for active addresses in this network */ count_addresses = 0; for (aw = net->head; NULL != aw; aw = aw->next) { if (GNUNET_YES != aw->addr->active) continue; - peer_relative_prefs = s->env->get_preferences (s->env->cls, &aw->addr->peer); - relative_peer_prefence = 0.0; - relative_peer_prefence += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH]; - sum_relative_peer_prefences += relative_peer_prefence; - count_addresses ++; + sum_relative_peer_prefences + += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH]; + count_addresses++; } - if (count_addresses != net->active_addresses) { GNUNET_break (0); LOG (GNUNET_ERROR_TYPE_WARNING, - "%s: Counted %u active addresses, but network says to have %u active addresses\n", + "%s: Counted %u active addresses, expected %u active addresses\n", net->desc, count_addresses, net->active_addresses); - for (aw = net->head; NULL != aw; aw = aw->next) - { - if (GNUNET_YES != aw->addr->active) - continue; - - LOG (GNUNET_ERROR_TYPE_WARNING, - "Active: `%s' `%s' length %u\n", - GNUNET_i2s (&aw->addr->peer), - aw->addr->plugin, - aw->addr->addr_len); - } + /* try to fix... */ + net->active_addresses = count_addresses; } - LOG (GNUNET_ERROR_TYPE_INFO, "Total relative preference %.3f for %u addresses in network %s\n", sum_relative_peer_prefences, net->active_addresses, net->desc); + /* check how much we have to distribute */ + remaining_quota_in = net->total_quota_in - (net->active_addresses * min_bw); + remaining_quota_out = net->total_quota_out - (net->active_addresses * min_bw); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Proportionally distributable bandwidth (in/out): %llu/%llu\n", + remaining_quota_in, + remaining_quota_out); + + /* distribute remaining quota; we do not do it exactly proportional, + but balance "even" distribution ("net->active_addresses") with + the preference sum using the "prop_factor". */ + total_weight = net->active_addresses + + s->prop_factor * sum_relative_peer_prefences; + quota_out_used = 0; + quota_in_used = 0; for (aw = net->head; NULL != aw; aw = aw->next) { - if (GNUNET_YES == aw->addr->active) - { - peer_relative_prefs = s->env->get_preferences (s->env->cls, - &aw->addr->peer); - - cur_pref = peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH]; - total_weight = net->active_addresses + - s->prop_factor * sum_relative_peer_prefences; - peer_weight = (1.0 + (s->prop_factor * cur_pref)); - - assigned_quota_in = min_bw - + ((peer_weight / total_weight) * remaining_quota_in); - assigned_quota_out = min_bw - + ((peer_weight / total_weight) * remaining_quota_out); - - LOG (GNUNET_ERROR_TYPE_INFO, - "New quota for peer `%s' with weight (cur/total) %.3f/%.3f (in/out): %llu / %llu\n", - GNUNET_i2s (&aw->addr->peer), - peer_weight, - total_weight, - assigned_quota_in, - assigned_quota_out); - } - else + if (GNUNET_YES != aw->addr->active) { - assigned_quota_in = 0; - assigned_quota_out = 0; + /* set to 0, just to be sure */ + aw->calculated_quota_in = 0; + aw->calculated_quota_out = 0; + continue; } + peer_relative_prefs = s->env->get_preferences (s->env->cls, + &aw->addr->peer); + peer_weight = 1.0 + + s->prop_factor * peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH]; - quota_in_used += assigned_quota_in; - quota_out_used += assigned_quota_out; - /* Prevent overflow due to rounding errors */ - if (assigned_quota_in > UINT32_MAX) - assigned_quota_in = UINT32_MAX; - if (assigned_quota_out > UINT32_MAX) - assigned_quota_out = UINT32_MAX; - - /* Store for later propagation */ - aw->calculated_quota_in = assigned_quota_in; - aw->calculated_quota_out = assigned_quota_out; + aw->calculated_quota_in = min_bw + + (peer_weight / total_weight) * remaining_quota_in; + aw->calculated_quota_out = min_bw + + (peer_weight / total_weight) * remaining_quota_out; + + LOG (GNUNET_ERROR_TYPE_INFO, + "New quotas for peer `%s' with weight (cur/total) %.3f/%.3f (in/out) are: %u/%u\n", + GNUNET_i2s (&aw->addr->peer), + peer_weight, + total_weight, + (unsigned int) aw->calculated_quota_in, + (unsigned int) aw->calculated_quota_out); + quota_in_used += aw->calculated_quota_in; + quota_out_used += aw->calculated_quota_out; } LOG (GNUNET_ERROR_TYPE_DEBUG, "Total bandwidth assigned is (in/out): %llu /%llu\n", quota_in_used, quota_out_used); - if (quota_out_used > net->total_quota_out + 1) /* +1 is required due to rounding errors */ - { - LOG (GNUNET_ERROR_TYPE_ERROR, - "Total outbound bandwidth assigned is larger than allowed (used/allowed) for %u active addresses: %llu / %llu\n", - net->active_addresses, - quota_out_used, - net->total_quota_out); - } - if (quota_in_used > net->total_quota_in + 1) /* +1 is required due to rounding errors */ - { - LOG (GNUNET_ERROR_TYPE_ERROR, - "Total inbound bandwidth assigned is larger than allowed (used/allowed) for %u active addresses: %llu / %llu\n", - net->active_addresses, - quota_in_used, - net->total_quota_in); - } + /* +1 due to possible rounding errors */ + GNUNET_break (quota_out_used <= net->total_quota_out + 1); + GNUNET_break (quota_in_used <= net->total_quota_in + 1); } @@ -629,7 +422,7 @@ distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s, { unsigned int i; - if (GNUNET_YES == s->bulk_lock) + if (0 != s->bulk_lock) { s->bulk_requests++; return; @@ -665,11 +458,14 @@ distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s, } else { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Redistributing bandwidth in all %u networks\n", + s->env->network_count); s->env->info_cb (s->env->cls, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL); - for (i = 0; i < s->network_count; i++) + for (i = 0; i < s->env->network_count; i++) distribute_bandwidth (s, &s->network_entries[i]); s->env->info_cb (s->env->cls, @@ -680,7 +476,7 @@ distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START, GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL); - for (i = 0; i < s->network_count; i++) + for (i = 0; i < s->env->network_count; i++) propagate_bandwidth (s, &s->network_entries[i]); s->env->info_cb (s->env->cls, @@ -708,27 +504,6 @@ struct FindBestAddressCtx }; -/** - * Find index of a ATS property type in the quality properties array. - * - * @param type ATS property type - * @return index in the quality array, #GNUNET_SYSERR if the type - * was not a quality property - */ -static int -find_quality_property_index (enum GNUNET_ATS_Property type) -{ - enum GNUNET_ATS_Property existing_types[] = GNUNET_ATS_QualityProperties; - unsigned int c; - - for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++) - if (existing_types[c] == type) - return c; - GNUNET_break (0); - return GNUNET_SYSERR; -} - - /** * Find a "good" address to use for a peer by iterating over the * addresses for this peer. If we already have an existing address, @@ -753,7 +528,6 @@ find_best_address_it (void *cls, double best_distance; double cur_delay; double cur_distance; - int index; unsigned int con; int bw_available; int need; @@ -762,7 +536,7 @@ find_best_address_it (void *cls, need = (GNUNET_YES == current->active) ? 0 : 1; /* we save -1 slot if 'best' is active and belongs to the same network (as we would replace it) */ - if ( (NULL == ctx->best) && + if ( (NULL != ctx->best) && (GNUNET_YES == ctx->best->active) && (((struct AddressWrapper *) ctx->best->solver_information)->network == asi->network) ) @@ -806,12 +580,10 @@ find_best_address_it (void *cls, } /* Now compare ATS information */ - index = find_quality_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE); - cur_distance = current->atsin[index].norm; - best_distance = ctx->best->atsin[index].norm; - index = find_quality_property_index (GNUNET_ATS_QUALITY_NET_DELAY); - cur_delay = current->atsin[index].norm; - best_delay = ctx->best->atsin[index].norm; + cur_distance = current->norm_distance.norm; + best_distance = ctx->best->norm_distance.norm; + cur_delay = current->norm_delay.norm; + best_delay = ctx->best->norm_delay.norm; /* user shorter distance */ if (cur_distance < best_distance) @@ -1020,7 +792,7 @@ update_active_address (struct GAS_PROPORTIONAL_Handle *s, } /* We do have a new address, activate it */ LOG (GNUNET_ERROR_TYPE_DEBUG, - "Suggesting new address %p for peer `%s'\n", + "Selecting new address %p for peer `%s'\n", best_address, GNUNET_i2s (peer)); /* Mark address as active */ @@ -1041,7 +813,6 @@ update_active_address (struct GAS_PROPORTIONAL_Handle *s, best_address, GNUNET_i2s (peer)); - if (GNUNET_NO == is_bandwidth_available_in_network (asi_best->network, 0)) @@ -1053,9 +824,10 @@ update_active_address (struct GAS_PROPORTIONAL_Handle *s, aw_min = NULL; for (aw = asi_best->network->head; NULL != aw; aw = aw->next) { - if (con_min > - (a_con = s->env->get_connectivity (s->env->cls, - &aw->addr->peer))) + if ( (con_min > + (a_con = s->env->get_connectivity (s->env->cls, + &aw->addr->peer))) && + (GNUNET_YES == aw->addr->active) ) { aw_min = aw; con_min = a_con; @@ -1064,8 +836,8 @@ update_active_address (struct GAS_PROPORTIONAL_Handle *s, } } update_active_address (s, - aw_con->addr, - &aw->addr->peer); + aw_min->addr, + &aw_min->addr->peer); } distribute_bandwidth_in_network (s, asi_best->network); @@ -1088,6 +860,8 @@ GAS_proportional_change_preference (void *solver, { struct GAS_PROPORTIONAL_Handle *s = solver; + if (GNUNET_ATS_PREFERENCE_BANDWIDTH != kind) + return; /* we do not care */ distribute_bandwidth_in_network (s, NULL); } @@ -1105,7 +879,7 @@ GAS_proportional_change_preference (void *solver, */ static void GAS_proportional_feedback (void *solver, - struct GNUNET_SERVER_Client *application, + struct GNUNET_SERVICE_Client *application, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TIME_Relative scope, enum GNUNET_ATS_PreferenceKind kind, @@ -1210,16 +984,10 @@ GAS_proportional_bulk_stop (void *solver) * * @param solver solver handle * @param address the address - * @param type the ATSI type in HBO - * @param abs_value the absolute value of the property - * @param rel_value the normalized value */ static void GAS_proportional_address_property_changed (void *solver, - struct ATS_Address *address, - enum GNUNET_ATS_Property type, - uint32_t abs_value, - double rel_value) + struct ATS_Address *address) { struct GAS_PROPORTIONAL_Handle *s = solver; struct AddressWrapper *asi = address->solver_information; @@ -1264,16 +1032,10 @@ GAS_proportional_address_add (void *solver, net->stat_total, 1, GNUNET_NO); - if (0 != - s->env->get_connectivity (s->env->cls, - &address->peer)) - { - /* This peer is requested, find best address */ - update_active_address (s, - get_active_address (s, - &address->peer), - &address->peer); - } + update_active_address (s, + get_active_address (s, + &address->peer), + &address->peer); LOG (GNUNET_ERROR_TYPE_INFO, "Added new address for `%s', now total %u and active %u addresses in network `%s'\n", GNUNET_i2s (&address->peer), @@ -1453,7 +1215,7 @@ libgnunet_plugin_ats_proportional_done (void *cls) struct AddressWrapper *next; unsigned int c; - for (c = 0; c < s->network_count; c++) + for (c = 0; c < s->env->network_count; c++) { GNUNET_break (0 == s->network_entries[c].total_addresses); GNUNET_break (0 == s->network_entries[c].active_addresses);