plugin_ats_proportional.c File Reference

ATS proportional solver. More...

#include "platform.h"
#include "gnunet_statistics_service.h"
#include "gnunet_ats_service.h"
#include "gnunet_ats_plugin.h"
#include "gnunet-service-ats_addresses.h"

Include dependency graph for plugin_ats_proportional.c:

Go to the source code of this file.

Data Structures
struct	AddressWrapper
	Address information stored for the proportional solver in the solver_information member of struct GNUNET_ATS_Address. More...
struct	Network
	Representation of a network. More...
struct	GAS_PROPORTIONAL_Handle
	A handle for the proportional solver. More...
struct	FindBestAddressCtx
	Context for finding the best address* Linked list of addresses in this network: head. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "ats-proportional", __VA_ARGS__)
#define	PROP_STABILITY_FACTOR   1.25
	How much do we value stability over adaptation by default. More...
#define	PROPORTIONALITY_FACTOR   2.0
	Default value to assume for the proportionality factor, if none is given in the configuration. More...

Functions
static int	is_bandwidth_available_in_network (struct Network *net, int extra)
	Test if bandwidth is available in this network to add an additional address. More...
static int	all_require_connectivity (struct GAS_PROPORTIONAL_Handle *s, struct Network *net, unsigned int con)
	Test if all peers in this network require connectivity at level at least con. More...
static void	distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s, struct Network *net)
	Update bandwidth assigned to peers in this network. More...
static void	propagate_bandwidth (struct GAS_PROPORTIONAL_Handle *s, struct Network *net)
	Notify ATS service of bandwidth changes to addresses. More...
static void	distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s, struct Network *n)
	Distribute bandwidth. More...
static int	find_best_address_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Find a "good" address to use for a peer by iterating over the addresses for this peer. More...
struct ATS_Address *	get_best_address (struct GAS_PROPORTIONAL_Handle *s, struct GNUNET_CONTAINER_MultiPeerMap *addresses, const struct GNUNET_PeerIdentity *id)
	Find the currently best address for a peer from the set of addresses available or return NULL of no address is available. More...
static void	address_decrement_active (struct GAS_PROPORTIONAL_Handle *s, struct Network *net)
	Decrease number of active addresses in network. More...
static int	get_active_address_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Address map iterator to find current active address for peer. More...
static struct ATS_Address *	get_active_address (struct GAS_PROPORTIONAL_Handle *s, const struct GNUNET_PeerIdentity *peer)
	Find current active address for peer. More...
static void	update_active_address (struct GAS_PROPORTIONAL_Handle *s, struct ATS_Address *current_address, const struct GNUNET_PeerIdentity *peer)
	Update active address for a peer. More...
static void	GAS_proportional_change_preference (void *solver, const struct GNUNET_PeerIdentity *peer, enum GNUNET_ATS_PreferenceKind kind, double pref_rel)
	The preferences for a peer in the problem changed. More...
static void	GAS_proportional_feedback (void *solver, struct GNUNET_SERVICE_Client *application, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_TIME_Relative scope, enum GNUNET_ATS_PreferenceKind kind, double score)
	Get application feedback for a peer. More...
static void	GAS_proportional_start_get_address (void *solver, const struct GNUNET_PeerIdentity *peer)
	Get the preferred address for a specific peer. More...
static void	GAS_proportional_stop_get_address (void *solver, const struct GNUNET_PeerIdentity *peer)
	Stop notifying about address and bandwidth changes for this peer. More...
static void	GAS_proportional_bulk_start (void *solver)
	Start a bulk operation. More...
static void	GAS_proportional_bulk_stop (void *solver)
	Bulk operation done. More...
static void	GAS_proportional_address_property_changed (void *solver, struct ATS_Address *address)
	Transport properties for this address have changed. More...
static void	GAS_proportional_address_add (void *solver, struct ATS_Address *address, uint32_t network)
	Add a new single address to a network. More...
static void	GAS_proportional_address_delete (void *solver, struct ATS_Address *address)
	Remove an address from the solver. More...
void *	libgnunet_plugin_ats_proportional_init (void *cls)
	Function invoked when the plugin is loaded. More...
void *	libgnunet_plugin_ats_proportional_done (void *cls)
	Function used to unload the plugin. More...

Detailed Description

ATS proportional solver.

Author

Matthias Wachs

Christian Grothoff

Definition in file plugin_ats_proportional.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "ats-proportional", __VA_ARGS__)

Definition at line 32 of file plugin_ats_proportional.c.

PROP_STABILITY_FACTOR

#define PROP_STABILITY_FACTOR   1.25

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.

Definition at line 40 of file plugin_ats_proportional.c.

PROPORTIONALITY_FACTOR

#define PROPORTIONALITY_FACTOR   2.0

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.

Definition at line 51 of file plugin_ats_proportional.c.

Function Documentation

is_bandwidth_available_in_network()

static int is_bandwidth_available_in_network ( struct Network *  net, int  extra  )

static

Test if bandwidth is available in this network to add an additional address.

Parameters

net	the network type to check
extra	for how many extra addresses do we check?

Returns

GNUNET_YES or GNUNET_NO

Definition at line 208 of file plugin_ats_proportional.c.

{
  unsigned int na;
  uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
 
  GNUNET_assert (((int) net->active_addresses) + extra >= 0);
  na = net->active_addresses + extra;
  if (0 == na)
    return GNUNET_YES;
  if (((net->total_quota_in / na) > min_bw) &&
      ((net->total_quota_out / na) > min_bw))
    return GNUNET_YES;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "No bandwidth available in network\n");
  return GNUNET_NO;
}

References Network::active_addresses, GNUNET_assert, GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_YES, LOG, Network::total_quota_in, and Network::total_quota_out.

Referenced by find_best_address_it(), and update_active_address().

Here is the caller graph for this function:

all_require_connectivity()

static int all_require_connectivity ( struct GAS_PROPORTIONAL_Handle *  s, struct Network *  net, unsigned int  con  )

static

Test if all peers in this network require connectivity at level at least con.

Parameters

s	the solver handle
net	the network type to check
con	connection return value threshold to check

Returns

GNUNET_YES or GNUNET_NO

Definition at line 237 of file plugin_ats_proportional.c.

{
  struct AddressWrapper *aw;
 
  for (aw = net->head; NULL != aw; aw = aw->next)
    if (con >
        s->env->get_connectivity (s->env->cls,
                                  &aw->addr->peer))
      return GNUNET_NO;
  return GNUNET_YES;
}

References AddressWrapper::addr, GNUNET_ATS_PluginEnvironment::cls, GAS_PROPORTIONAL_Handle::env, GNUNET_ATS_PluginEnvironment::get_connectivity, GNUNET_NO, GNUNET_YES, Network::head, AddressWrapper::next, and ATS_Address::peer.

Referenced by find_best_address_it().

Here is the caller graph for this function:

distribute_bandwidth()

static void distribute_bandwidth ( struct GAS_PROPORTIONAL_Handle *  s, struct Network *  net  )

static

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.

Parameters

s	the solver handle
net	the network type to update

Definition at line 262 of file plugin_ats_proportional.c.

{
  const uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
  struct AddressWrapper *aw;
  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;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Recalculate quota for network type `%s' for %u addresses (in/out): %llu/%llu \n",
       net->desc,
       net->active_addresses,
       net->total_quota_in,
       net->total_quota_in);
 
  if (0 == net->active_addresses)
    return; /* no addresses to update */
 
  /* sanity checks */
  if ((net->active_addresses * min_bw) > net->total_quota_in)
  {
    GNUNET_break (0);
    return;
  }
  if ((net->active_addresses * min_bw) > net->total_quota_out)
  {
    GNUNET_break (0);
    return;
  }
 
  /* Calculate sum of relative preference for active addresses in this
     network */
  sum_relative_peer_prefences = 0.0;
  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);
    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, expected %u active addresses\n",
         net->desc,
         count_addresses,
         net->active_addresses);
    /* 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)
    {
      /* 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];
 
    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);
  /* +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);
}

References ATS_Address::active, Network::active_addresses, AddressWrapper::addr, AddressWrapper::calculated_quota_in, AddressWrapper::calculated_quota_out, GNUNET_ATS_PluginEnvironment::cls, count_addresses(), Network::desc, GAS_PROPORTIONAL_Handle::env, GNUNET_ATS_PluginEnvironment::get_preferences, GNUNET_ATS_PREFERENCE_BANDWIDTH, GNUNET_break, GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_YES, Network::head, LOG, AddressWrapper::next, ATS_Address::peer, GAS_PROPORTIONAL_Handle::prop_factor, Network::total_quota_in, and Network::total_quota_out.

Referenced by distribute_bandwidth_in_network().

Here is the call graph for this function:

Here is the caller graph for this function:

propagate_bandwidth()

static void propagate_bandwidth ( struct GAS_PROPORTIONAL_Handle *  s, struct Network *  net  )

static

Notify ATS service of bandwidth changes to addresses.

Parameters

s	solver handle
net	the network to propagate changes in

Definition at line 394 of file plugin_ats_proportional.c.

{
  struct AddressWrapper *cur;
 
  for (cur = net->head; NULL != cur; cur = cur->next)
  {
    if ((cur->addr->assigned_bw_in == cur->calculated_quota_in) &&
        (cur->addr->assigned_bw_out == cur->calculated_quota_out))
      continue;
    cur->addr->assigned_bw_in = cur->calculated_quota_in;
    cur->addr->assigned_bw_out = cur->calculated_quota_out;
    if (GNUNET_YES == cur->addr->active)
      s->env->bandwidth_changed_cb (s->env->cls,
                                    cur->addr);
  }
}

References ATS_Address::active, AddressWrapper::addr, ATS_Address::assigned_bw_in, ATS_Address::assigned_bw_out, GNUNET_ATS_PluginEnvironment::bandwidth_changed_cb, AddressWrapper::calculated_quota_in, AddressWrapper::calculated_quota_out, GNUNET_ATS_PluginEnvironment::cls, GAS_PROPORTIONAL_Handle::env, GNUNET_YES, Network::head, and AddressWrapper::next.

Referenced by distribute_bandwidth_in_network().

Here is the caller graph for this function:

distribute_bandwidth_in_network()

static void distribute_bandwidth_in_network ( struct GAS_PROPORTIONAL_Handle *  s, struct Network *  n  )

static

Distribute bandwidth.

The addresses have already been selected, this is merely distributed the bandwidth among the addresses.

Parameters

s	the solver handle
n	the network, can be NULL for all networks

Definition at line 421 of file plugin_ats_proportional.c.

{
  unsigned int i;
 
  if (0 != s->bulk_lock)
  {
    s->bulk_requests++;
    return;
  }
  if (NULL != n)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Redistributing bandwidth in network %s with %u active and %u total addresses\n",
         GNUNET_NT_to_string (n->type),
         n->active_addresses,
         n->total_addresses);
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_START,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_SINGLE);
    distribute_bandwidth (s,
                          n);
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_STOP,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_SINGLE);
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_SINGLE);
    propagate_bandwidth (s,
                         n);
 
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_SINGLE);
  }
  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->env->network_count; i++)
      distribute_bandwidth (s,
                            &s->network_entries[i]);
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_STOP,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_ALL);
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_ALL);
    for (i = 0; i < s->env->network_count; i++)
      propagate_bandwidth (s,
                           &s->network_entries[i]);
    s->env->info_cb (s->env->cls,
                     GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
                     GAS_STAT_SUCCESS,
                     GAS_INFO_PROP_ALL);
  }
}

References Network::active_addresses, GAS_PROPORTIONAL_Handle::bulk_lock, GAS_PROPORTIONAL_Handle::bulk_requests, GNUNET_ATS_PluginEnvironment::cls, distribute_bandwidth(), GAS_PROPORTIONAL_Handle::env, GAS_INFO_PROP_ALL, GAS_INFO_PROP_SINGLE, GAS_OP_SOLVE_START, GAS_OP_SOLVE_STOP, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP, GAS_STAT_SUCCESS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NT_to_string(), GNUNET_ATS_PluginEnvironment::info_cb, LOG, GNUNET_ATS_PluginEnvironment::network_count, GAS_PROPORTIONAL_Handle::network_entries, propagate_bandwidth(), Network::total_addresses, and Network::type.

Referenced by GAS_proportional_address_delete(), GAS_proportional_address_property_changed(), GAS_proportional_bulk_stop(), GAS_proportional_change_preference(), GAS_proportional_stop_get_address(), and update_active_address().

Here is the call graph for this function:

Here is the caller graph for this function:

find_best_address_it()

static int find_best_address_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Find a "good" address to use for a peer by iterating over the addresses for this peer.

If we already have an existing address, we stick to it. Otherwise, we pick by lowest distance and then by lowest latency.

Parameters

cls	the ‘struct FindBestAddressCtx *’ where we store the result
key	the peer we are trying to find the best address for
value	another struct ATS_Address* to consider using

Returns

GNUNET_OK (continue to iterate)

Definition at line 520 of file plugin_ats_proportional.c.

{
  struct FindBestAddressCtx *ctx = cls;
  struct ATS_Address *current = value;
  struct AddressWrapper *asi = current->solver_information;
  struct GNUNET_TIME_Relative active_time;
  double best_delay;
  double best_distance;
  double cur_delay;
  double cur_distance;
  unsigned int con;
  int bw_available;
  int need;
 
  /* we need +1 slot if 'current' is not yet active */
  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) &&
      (GNUNET_YES == ctx->best->active) &&
      (((struct AddressWrapper *) ctx->best->solver_information)->network ==
       asi->network))
    need--;
  /* we can gain -1 slot if this peers connectivity
     requirement is higher than that of another peer
     in that network scope */
  con = ctx->s->env->get_connectivity (ctx->s->env->cls,
                                       key);
  if (GNUNET_YES !=
      all_require_connectivity (ctx->s,
                                asi->network,
                                con))
    need--;
  /* test if minimum bandwidth for 'current' would be available */
  bw_available
    = is_bandwidth_available_in_network (asi->network,
                                         need);
  if (! bw_available)
  {
    /* Bandwidth for this address is unavailable, so we cannot use
       it. */
    return GNUNET_OK;
  }
  if (GNUNET_YES == current->active)
  {
    active_time = GNUNET_TIME_absolute_get_duration (asi->activated);
    if (active_time.rel_value_us <=
        ((double) GNUNET_TIME_UNIT_SECONDS.rel_value_us)
        * ctx->s->stability_factor)
    {
      /* Keep active address for stability reasons */
      ctx->best = current;
      return GNUNET_NO;
    }
  }
  if (NULL == ctx->best)
  {
    /* We so far have nothing else, so go with it! */
    ctx->best = current;
    return GNUNET_OK;
  }
 
  /* Now compare ATS information */
  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)
  {
    if (GNUNET_NO == ctx->best->active)
    {
      /* Activity doesn't influence the equation, use current */
      ctx->best = current;
    }
    else if ((best_distance / cur_distance) > ctx->s->stability_factor)
    {
      /* Distance change is significant, switch active address! */
      ctx->best = current;
    }
  }
 
  /* User connection with less delay */
  if (cur_delay < best_delay)
  {
    if (GNUNET_NO == ctx->best->active)
    {
      /* Activity doesn't influence the equation, use current */
      ctx->best = current;
    }
    else if ((best_delay / cur_delay) > ctx->s->stability_factor)
    {
      /* Latency change is significant, switch active address! */
      ctx->best = current;
    }
  }
  return GNUNET_OK;
}

References AddressWrapper::activated, ATS_Address::active, all_require_connectivity(), ctx, GNUNET_NO, GNUNET_OK, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, is_bandwidth_available_in_network(), key, AddressWrapper::network, GAS_NormalizationInfo::norm, ATS_Address::norm_delay, ATS_Address::norm_distance, GNUNET_TIME_Relative::rel_value_us, ATS_Address::solver_information, and value.

Referenced by get_best_address().

Here is the call graph for this function:

Here is the caller graph for this function:

get_best_address()

struct ATS_Address* get_best_address	(	struct GAS_PROPORTIONAL_Handle *	s,
		struct GNUNET_CONTAINER_MultiPeerMap *	addresses,
		const struct GNUNET_PeerIdentity *	id
	)

Find the currently best address for a peer from the set of addresses available or return NULL of no address is available.

Parameters

s	the proportional handle
addresses	the address hashmap
id	the peer id

Returns

the address or NULL

Definition at line 633 of file plugin_ats_proportional.c.

{
  struct FindBestAddressCtx fba_ctx;
 
  fba_ctx.best = NULL;
  fba_ctx.s = s;
  GNUNET_CONTAINER_multipeermap_get_multiple (addresses,
                                              id,
                                              &find_best_address_it,
                                              &fba_ctx);
  return fba_ctx.best;
}

References addresses, FindBestAddressCtx::best, find_best_address_it(), GNUNET_CONTAINER_multipeermap_get_multiple(), and FindBestAddressCtx::s.

Referenced by update_active_address().

Here is the call graph for this function:

Here is the caller graph for this function:

address_decrement_active()

static void address_decrement_active ( struct GAS_PROPORTIONAL_Handle *  s, struct Network *  net  )

static

Decrease number of active addresses in network.

Parameters

s	the solver handle
net	the network type

Definition at line 656 of file plugin_ats_proportional.c.

{
  GNUNET_assert (net->active_addresses > 0);
  net->active_addresses--;
  GNUNET_STATISTICS_update (s->env->stats,
                            net->stat_active,
                            -1,
                            GNUNET_NO);
  GNUNET_assert (s->active_addresses > 0);
  s->active_addresses--;
  GNUNET_STATISTICS_update (s->env->stats,
                            "# ATS addresses total",
                            -1,
                            GNUNET_NO);
}

References Network::active_addresses, GAS_PROPORTIONAL_Handle::active_addresses, GAS_PROPORTIONAL_Handle::env, GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_update(), FindBestAddressCtx::s, Network::stat_active, and GNUNET_ATS_PluginEnvironment::stats.

Referenced by update_active_address().

Here is the call graph for this function:

Here is the caller graph for this function:

get_active_address_it()

static int get_active_address_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Address map iterator to find current active address for peer.

Asserts that only one address is active per peer.

Parameters

cls	last active address
key	peer's key
value	address to check

Returns

GNUNET_NO on double active address else GNUNET_YES;

Definition at line 684 of file plugin_ats_proportional.c.

{
  struct ATS_Address **dest = cls;
  struct ATS_Address *aa = value;
 
  if (GNUNET_YES != aa->active)
    return GNUNET_OK;
  GNUNET_assert (NULL == (*dest));
  (*dest) = aa;
  return GNUNET_OK;
}

References ATS_Address::active, warningfilter::dest, GNUNET_assert, GNUNET_OK, GNUNET_YES, and value.

Referenced by get_active_address().

Here is the caller graph for this function:

get_active_address()

static struct ATS_Address* get_active_address ( struct GAS_PROPORTIONAL_Handle *  s, const struct GNUNET_PeerIdentity *  peer  )

static

Find current active address for peer.

Parameters

s	the solver handle
peer	the peer

Returns

active address or NULL

Definition at line 707 of file plugin_ats_proportional.c.

{
  struct ATS_Address *dest;
 
  dest = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (s->env->addresses,
                                              peer,
                                              &get_active_address_it,
                                              &dest);
  return dest;
}

References GNUNET_ATS_PluginEnvironment::addresses, warningfilter::dest, GAS_PROPORTIONAL_Handle::env, get_active_address_it(), GNUNET_CONTAINER_multipeermap_get_multiple(), and peer.

Referenced by GAS_proportional_address_add(), GAS_proportional_start_get_address(), and GAS_proportional_stop_get_address().

Here is the call graph for this function:

Here is the caller graph for this function:

update_active_address()

static void update_active_address ( struct GAS_PROPORTIONAL_Handle *  s, struct ATS_Address *  current_address, const struct GNUNET_PeerIdentity *  peer  )

static

Update active address for a peer.

Check if active address exists and what the best address is, if addresses are different switch. Then reallocate bandwidth within the affected network scopes.

Parameters

s	solver handle
current_address	the address currently active for the peer, NULL for none
peer	the peer to check

Definition at line 732 of file plugin_ats_proportional.c.

{
  struct ATS_Address *best_address;
  struct AddressWrapper *asi_cur;
  struct AddressWrapper *asi_best;
  struct AddressWrapper *aw;
  struct AddressWrapper *aw_min;
  unsigned int a_con;
  unsigned int con_min;
 
  best_address = get_best_address (s,
                                   s->env->addresses,
                                   peer);
  if (NULL != best_address)
    asi_best = best_address->solver_information;
  else
    asi_best = NULL;
  if (current_address == best_address)
    return; /* no changes */
  if (NULL != current_address)
  {
    /* We switch to a new address (or to none);
       mark old address as inactive. */
    asi_cur = current_address->solver_information;
    GNUNET_assert (GNUNET_YES == current_address->active);
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Disabling previous active address for peer `%s'\n",
         GNUNET_i2s (peer));
    asi_cur->activated = GNUNET_TIME_UNIT_ZERO_ABS;
    current_address->active = GNUNET_NO;
    current_address->assigned_bw_in = 0;
    current_address->assigned_bw_out = 0;
    address_decrement_active (s,
                              asi_cur->network);
    if ((NULL == best_address) ||
        (asi_best->network != asi_cur->network))
      distribute_bandwidth_in_network (s,
                                       asi_cur->network);
    if (NULL == best_address)
    {
      /* We previously had an active address, but now we cannot
       * suggest one.  Therefore we have to disconnect the peer.
       * The above call to "distribute_bandwidth_in_network()
       * does not see 'current_address' so we need to trigger
       * the update here. */LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Disconnecting peer `%s'.\n",
           GNUNET_i2s (peer));
      s->env->bandwidth_changed_cb (s->env->cls,
                                    current_address);
      return;
    }
  }
  if (NULL == best_address)
  {
    /* We do not have a new address, so we are done. */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Cannot suggest address for peer `%s'\n",
         GNUNET_i2s (peer));
    return;
  }
  /* We do have a new address, activate it */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Selecting new address %p for peer `%s'\n",
       best_address,
       GNUNET_i2s (peer));
  /* Mark address as active */
  best_address->active = GNUNET_YES;
  asi_best->activated = GNUNET_TIME_absolute_get ();
  asi_best->network->active_addresses++;
  s->active_addresses++;
  GNUNET_STATISTICS_update (s->env->stats,
                            "# ATS active addresses total",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (s->env->stats,
                            asi_best->network->stat_active,
                            1,
                            GNUNET_NO);
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Address %p for peer `%s' is now active\n",
       best_address,
       GNUNET_i2s (peer));
 
  if (GNUNET_NO ==
      is_bandwidth_available_in_network (asi_best->network,
                                         0))
  {
    /* we went over the maximum number of addresses for
       this scope; remove the address with the smallest
       connectivity requirement */
    con_min = UINT32_MAX;
    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))) &&
          (GNUNET_YES == aw->addr->active))
      {
        aw_min = aw;
        con_min = a_con;
        if (0 == con_min)
          break;
      }
    }
    update_active_address (s,
                           aw_min->addr,
                           &aw_min->addr->peer);
  }
  distribute_bandwidth_in_network (s,
                                   asi_best->network);
}

References AddressWrapper::activated, ATS_Address::active, Network::active_addresses, GAS_PROPORTIONAL_Handle::active_addresses, AddressWrapper::addr, address_decrement_active(), GNUNET_ATS_PluginEnvironment::addresses, ATS_Address::assigned_bw_in, ATS_Address::assigned_bw_out, GNUNET_ATS_PluginEnvironment::bandwidth_changed_cb, GNUNET_ATS_PluginEnvironment::cls, distribute_bandwidth_in_network(), GAS_PROPORTIONAL_Handle::env, get_best_address(), GNUNET_ATS_PluginEnvironment::get_connectivity, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, Network::head, is_bandwidth_available_in_network(), LOG, AddressWrapper::network, AddressWrapper::next, ATS_Address::peer, peer, ATS_Address::solver_information, Network::stat_active, and GNUNET_ATS_PluginEnvironment::stats.

Referenced by GAS_proportional_address_add(), GAS_proportional_address_delete(), and GAS_proportional_start_get_address().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_change_preference()

static void GAS_proportional_change_preference ( void *  solver, const struct GNUNET_PeerIdentity *  peer, enum GNUNET_ATS_PreferenceKind  kind, double  pref_rel  )

static

The preferences for a peer in the problem changed.

Parameters

solver	the solver handle
peer	the peer to change the preference for
kind	the kind to change the preference
pref_rel	the normalized preference value for this kind over all clients

Definition at line 857 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
 
  if (GNUNET_ATS_PREFERENCE_BANDWIDTH != kind)
    return; /* we do not care */
  distribute_bandwidth_in_network (s,
                                   NULL);
}

References distribute_bandwidth_in_network(), and GNUNET_ATS_PREFERENCE_BANDWIDTH.

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_feedback()

static void GAS_proportional_feedback ( void *  solver, struct GNUNET_SERVICE_Client *  application, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_TIME_Relative  scope, enum GNUNET_ATS_PreferenceKind  kind, double  score  )

static

Get application feedback for a peer.

Parameters

solver	the solver handle
application	the application
peer	the peer to change the preference for
scope	the time interval for this feedback: [now - scope .. now]
kind	the kind to change the preference
score	the score

Definition at line 882 of file plugin_ats_proportional.c.

{
  /* Proportional does not care about feedback */
}

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the caller graph for this function:

GAS_proportional_start_get_address()

static void GAS_proportional_start_get_address ( void *  solver, const struct GNUNET_PeerIdentity *  peer  )

static

Get the preferred address for a specific peer.

Parameters

solver	the solver handle
peer	the identity of the peer

Definition at line 900 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
 
  update_active_address (s,
                         get_active_address (s,
                                             peer),
                         peer);
}

References get_active_address(), peer, and update_active_address().

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_stop_get_address()

static void GAS_proportional_stop_get_address ( void *  solver, const struct GNUNET_PeerIdentity *  peer  )

static

Stop notifying about address and bandwidth changes for this peer.

Parameters

solver	the solver handle
peer	the peer

Definition at line 919 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
  struct ATS_Address *cur;
  struct AddressWrapper *asi;
 
  cur = get_active_address (s,
                            peer);
  if (NULL == cur)
    return;
  asi = cur->solver_information;
  distribute_bandwidth_in_network (s,
                                   asi->network);
}

References distribute_bandwidth_in_network(), get_active_address(), AddressWrapper::network, peer, and ATS_Address::solver_information.

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_bulk_start()

static void GAS_proportional_bulk_start ( void *  solver )

static

Start a bulk operation.

Parameters

solver

the solver

Definition at line 942 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Locking solver for bulk operation ...\n");
  GNUNET_assert (NULL != solver);
  s->bulk_lock++;
}

References GAS_PROPORTIONAL_Handle::bulk_lock, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, and LOG.

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the caller graph for this function:

GAS_proportional_bulk_stop()

static void GAS_proportional_bulk_stop ( void *  solver )

static

Bulk operation done.

Parameters

solver

our struct GAS_PROPORTIONAL_Handle *

Definition at line 959 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Unlocking solver from bulk operation ...\n");
  if (s->bulk_lock < 1)
  {
    GNUNET_break (0);
    return;
  }
  s->bulk_lock--;
  if ((0 == s->bulk_lock) &&
      (0 < s->bulk_requests))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "No lock pending, recalculating\n");
    distribute_bandwidth_in_network (s,
                                     NULL);
    s->bulk_requests = 0;
  }
}

References GAS_PROPORTIONAL_Handle::bulk_lock, GAS_PROPORTIONAL_Handle::bulk_requests, distribute_bandwidth_in_network(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, and LOG.

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_address_property_changed()

static void GAS_proportional_address_property_changed ( void *  solver, struct ATS_Address *  address  )

static

Transport properties for this address have changed.

Parameters

solver	solver handle
address	the address

Definition at line 990 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
  struct AddressWrapper *asi = address->solver_information;
 
  distribute_bandwidth_in_network (s,
                                   asi->network);
}

References address, distribute_bandwidth_in_network(), and AddressWrapper::network.

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_address_add()

static void GAS_proportional_address_add ( void *  solver, struct ATS_Address *  address, uint32_t  network  )

static

Add a new single address to a network.

Parameters

solver	the solver Handle
address	the address to add
network	network type of this address

Definition at line 1009 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
  struct Network *net;
  struct AddressWrapper *aw;
 
  GNUNET_assert (network < s->env->network_count);
  net = &s->network_entries[network];
  net->total_addresses++;
 
  aw = GNUNET_new (struct AddressWrapper);
  aw->addr = address;
  aw->network = net;
  address->solver_information = aw;
  GNUNET_CONTAINER_DLL_insert (net->head,
                               net->tail,
                               aw);
  GNUNET_STATISTICS_update (s->env->stats,
                            "# ATS addresses total",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (s->env->stats,
                            net->stat_total,
                            1,
                            GNUNET_NO);
  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),
       net->total_addresses,
       net->active_addresses,
       net->desc);
}

References Network::active_addresses, AddressWrapper::addr, address, Network::desc, env, GAS_PROPORTIONAL_Handle::env, get_active_address(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), Network::head, LOG, AddressWrapper::network, GAS_PROPORTIONAL_Handle::network_entries, Network::stat_total, GNUNET_ATS_PluginEnvironment::stats, Network::tail, Network::total_addresses, and update_active_address().

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GAS_proportional_address_delete()

static void GAS_proportional_address_delete ( void *  solver, struct ATS_Address *  address  )

static

Remove an address from the solver.

To do so, we:

• Removed it from specific network
• Decrease the number of total addresses
• If active:
  • decrease number of active addresses
  • update quotas

Parameters

solver	the solver handle
address	the address to remove

Definition at line 1061 of file plugin_ats_proportional.c.

{
  struct GAS_PROPORTIONAL_Handle *s = solver;
  struct AddressWrapper *aw = address->solver_information;
  struct Network *net = aw->network;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Deleting %s address for peer `%s' from network `%s' (total: %u/active: %u)\n",
       (GNUNET_NO == address->active) ? "inactive" : "active",
       GNUNET_i2s (&address->peer),
       net->desc,
       net->total_addresses,
       net->active_addresses);
 
  GNUNET_CONTAINER_DLL_remove (net->head,
                               net->tail,
                               aw);
  GNUNET_assert (net->total_addresses > 0);
  net->total_addresses--;
  GNUNET_STATISTICS_update (s->env->stats,
                            net->stat_total,
                            -1,
                            GNUNET_NO);
  if (GNUNET_YES == address->active)
  {
    /* Address was active, remove from network and update quotas */
    update_active_address (s,
                           address,
                           &address->peer);
    distribute_bandwidth_in_network (s, net);
  }
  GNUNET_free (aw);
  address->solver_information = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "After deleting address now total %u and active %u addresses in network `%s'\n",
       net->total_addresses,
       net->active_addresses,
       net->desc);
}

References Network::active_addresses, address, Network::desc, distribute_bandwidth_in_network(), GAS_PROPORTIONAL_Handle::env, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, Network::head, LOG, AddressWrapper::network, Network::stat_total, GNUNET_ATS_PluginEnvironment::stats, Network::tail, Network::total_addresses, and update_active_address().

Referenced by libgnunet_plugin_ats_proportional_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_ats_proportional_init()

void* libgnunet_plugin_ats_proportional_init

(

void *

cls

)

Function invoked when the plugin is loaded.

Parameters

[in,out]

cls

the struct GNUNET_ATS_PluginEnvironment * to use; modified to return the API functions (ugh).

Returns

the struct GAS_PROPORTIONAL_Handle to pass as a closure

Definition at line 1111 of file plugin_ats_proportional.c.

{
  static struct GNUNET_ATS_SolverFunctions sf;
  struct GNUNET_ATS_PluginEnvironment *env = cls;
  struct GAS_PROPORTIONAL_Handle *s;
  struct Network *cur;
  float f_tmp;
  unsigned int c;
 
  s = GNUNET_new (struct GAS_PROPORTIONAL_Handle);
  s->env = env;
  sf.cls = s;
  sf.s_add = &GAS_proportional_address_add;
  sf.s_address_update_property = &GAS_proportional_address_property_changed;
  sf.s_get = &GAS_proportional_start_get_address;
  sf.s_get_stop = &GAS_proportional_stop_get_address;
  sf.s_pref = &GAS_proportional_change_preference;
  sf.s_feedback = &GAS_proportional_feedback;
  sf.s_del = &GAS_proportional_address_delete;
  sf.s_bulk_start = &GAS_proportional_bulk_start;
  sf.s_bulk_stop = &GAS_proportional_bulk_stop;
  s->stability_factor = PROP_STABILITY_FACTOR;
  if (GNUNET_SYSERR !=
      GNUNET_CONFIGURATION_get_value_float (env->cfg,
                                            "ats",
                                            "PROP_STABILITY_FACTOR",
                                            &f_tmp))
  {
    if ((f_tmp < 1.0) || (f_tmp > 2.0))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Invalid %s configuration %f \n"),
           "PROP_STABILITY_FACTOR",
           f_tmp);
    }
    else
    {
      s->stability_factor = f_tmp;
      LOG (GNUNET_ERROR_TYPE_INFO,
           "Using %s of %.3f\n",
           "PROP_STABILITY_FACTOR",
           f_tmp);
    }
  }
  s->prop_factor = PROPORTIONALITY_FACTOR;
  if (GNUNET_SYSERR !=
      GNUNET_CONFIGURATION_get_value_float (env->cfg,
                                            "ats",
                                            "PROP_PROPORTIONALITY_FACTOR",
                                            &f_tmp))
  {
    if (f_tmp < 1.0)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Invalid %s configuration %f\n"),
           "PROP_PROPORTIONALITY_FACTOR",
           f_tmp);
    }
    else
    {
      s->prop_factor = f_tmp;
      LOG (GNUNET_ERROR_TYPE_INFO,
           "Using %s of %.3f\n",
           "PROP_PROPORTIONALITY_FACTOR",
           f_tmp);
    }
  }
 
  s->network_entries = GNUNET_malloc (env->network_count
                                      * sizeof(struct Network));
  for (c = 0; c < env->network_count; c++)
  {
    cur = &s->network_entries[c];
    cur->type = c;
    cur->total_quota_in = env->in_quota[c];
    cur->total_quota_out = env->out_quota[c];
    cur->desc = GNUNET_NT_to_string (c);
    GNUNET_asprintf (&cur->stat_total,
                     "# ATS addresses %s total",
                     cur->desc);
    GNUNET_asprintf (&cur->stat_active,
                     "# ATS active addresses %s total",
                     cur->desc);
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Added network %u `%s' (%llu/%llu)\n",
         c,
         cur->desc,
         cur->total_quota_in,
         cur->total_quota_out);
  }
  return &sf;
}

References _, GNUNET_ATS_SolverFunctions::cls, GNUNET_ATS_PluginEnvironment::cls, Network::desc, env, GAS_PROPORTIONAL_Handle::env, GAS_proportional_address_add(), GAS_proportional_address_delete(), GAS_proportional_address_property_changed(), GAS_proportional_bulk_start(), GAS_proportional_bulk_stop(), GAS_proportional_change_preference(), GAS_proportional_feedback(), GAS_proportional_start_get_address(), GAS_proportional_stop_get_address(), GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_float(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_malloc, GNUNET_new, GNUNET_NT_to_string(), GNUNET_SYSERR, LOG, GAS_PROPORTIONAL_Handle::network_entries, GAS_PROPORTIONAL_Handle::prop_factor, PROP_STABILITY_FACTOR, PROPORTIONALITY_FACTOR, GNUNET_ATS_SolverFunctions::s_add, GNUNET_ATS_SolverFunctions::s_address_update_property, GNUNET_ATS_SolverFunctions::s_bulk_start, GNUNET_ATS_SolverFunctions::s_bulk_stop, GNUNET_ATS_SolverFunctions::s_del, GNUNET_ATS_SolverFunctions::s_feedback, GNUNET_ATS_SolverFunctions::s_get, GNUNET_ATS_SolverFunctions::s_get_stop, GNUNET_ATS_SolverFunctions::s_pref, sf, GAS_PROPORTIONAL_Handle::stability_factor, Network::stat_active, Network::stat_total, Network::total_quota_in, Network::total_quota_out, and Network::type.

Here is the call graph for this function:

libgnunet_plugin_ats_proportional_done()

void* libgnunet_plugin_ats_proportional_done

(

void *

cls

)

Function used to unload the plugin.

Parameters

cls	return value from libgnunet_plugin_ats_proportional_init()

Definition at line 1211 of file plugin_ats_proportional.c.

{
  struct GNUNET_ATS_SolverFunctions *sf = cls;
  struct GAS_PROPORTIONAL_Handle *s = sf->cls;
  struct AddressWrapper *cur;
  struct AddressWrapper *next;
  unsigned int 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);
    next = s->network_entries[c].head;
    while (NULL != (cur = next))
    {
      next = cur->next;
      GNUNET_CONTAINER_DLL_remove (s->network_entries[c].head,
                                   s->network_entries[c].tail,
                                   cur);
      GNUNET_free (cur->addr->solver_information);
      GNUNET_free (cur);
    }
    GNUNET_free (s->network_entries[c].stat_total);
    GNUNET_free (s->network_entries[c].stat_active);
  }
  GNUNET_break (0 == s->active_addresses);
  GNUNET_free (s->network_entries);
  GNUNET_free (s);
  return NULL;
}

References Network::active_addresses, GAS_PROPORTIONAL_Handle::active_addresses, AddressWrapper::addr, GNUNET_ATS_SolverFunctions::cls, GAS_PROPORTIONAL_Handle::env, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, Network::head, GNUNET_ATS_PluginEnvironment::network_count, GAS_PROPORTIONAL_Handle::network_entries, AddressWrapper::next, sf, ATS_Address::solver_information, Network::stat_active, Network::stat_total, Network::tail, and Network::total_addresses.