src/ats/libgnunet_plugin_ats_proportional.c

   1 /*
   2  This file is part of GNUnet.
   3  (C) 2011 Christian Grothoff (and other contributing authors)
   4
   5  GNUnet is free software; you can redistribute it and/or modify
   6  it under the terms of the GNU General Public License as published
   7  by the Free Software Foundation; either version 3, or (at your
   8  option) any later version.
   9
  10  GNUnet is distributed in the hope that it will be useful, but
  11  WITHOUT ANY WARRANTY; without even the implied warranty of
  12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  General Public License for more details.
  14
  15  You should have received a copy of the GNU General Public License
  16  along with GNUnet; see the file COPYING.  If not, write to the
  17  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * @file ats/libgnunet_plugin_ats_proportional.c
  23  * @brief ATS proportional solver
  24  * @author Matthias Wachs
  25  * @author Christian Grothoff
  26  */
  27 #include "libgnunet_plugin_ats_proportional.h"
  28
  29 #define LOG(kind,...) GNUNET_log_from (kind, "ats-proportional",__VA_ARGS__)
  30
  31
  32 /**
  33  *
  34  * NOTE: Do not change this documentation. This documentation is based
  35  * on gnunet.org:/vcs/fsnsg/ats-paper.git/tech-doku/ats-tech-guide.tex
  36  * use build_txt.sh to generate plaintext output
  37  *
  38  * ATS addresses : proportional solver
  39  *
  40  *    The proportional solver ("proportional") distributes the available
  41  *    bandwidth fair over all the addresses influenced by the
  42  *    preference values. For each available network type an in- and
  43  *    outbound quota is configured and the bandwidth available in
  44  *    these networks is distributed over the addresses.  The solver
  45  *    first assigns every addresses the minimum amount of bandwidth
  46  *    GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT and then distributes the
  47  *    remaining bandwidth available according to the preference
  48  *    values. For each peer only a single address gets bandwidth
  49  *    assigned and only one address marked as active.  The most
  50  *    important functionality for the solver is implemented in: *
  51  *    find_address_it is an hashmap iterator returning the prefered
  52  *    address for an peer * update_quota_per_network distributes
  53  *    available bandwidth for a network over active addresses
  54  *
  55  *    Changes to addresses automatically have an impact on the the
  56  *    bandwidth assigned to other addresses in the same network since
  57  *    the solver distributes the remaining bandwidth over the
  58  *    addresses in the network.  When changes to the addresses occur,
  59  *    the solver first performs the changes, like adding or deleting
  60  *    addresses, and then updates bandwidth assignment for the
  61  *    affected network. Bandwidth assignment is only recalculated on
  62  *    demand when an address is requested by a client for a peer or
  63  *    when the addresses available have changed or an address changed
  64  *    the network it is located in. When the bandwidth assignment has
  65  *    changed the callback is called with the new bandwidth
  66  *    assignments. The bandwidth distribution for a network is
  67  *    recalculated due to: * address suggestion requests * address
  68  *    deletions * address switching networks during address update *
  69  *    preference changes
  70  *
  71  *     3.1 Data structures used
  72  *
  73  *    For each ATS network (e.g. WAN, LAN, loopback) a struct Network
  74  *    is used to specify network related information as total adresses
  75  *    and active addresses in this network and the configured in- and
  76  *    outbound quota. Each network also contains a list of addresses
  77  *    added to the solver located in this network. The proportional
  78  *    solver uses the addresses' solver_information field to store the
  79  *    proportional network it belongs to for each address.
  80  *
  81  *     3.2 Initializing
  82  *
  83  *    When the proportional solver is initialized the solver creates a
  84  *    new solver handle and initializes the network structures with
  85  *    the quotas passed from addresses and returns the handle solver.
  86  *
  87  *     3.3 Adding an address
  88  *
  89  *    When a new address is added to the solver using s_add, a lookup
  90  *    for the network for this address is done and the address is
  91  *    enqueued in in the linked list of the network.
  92  *
  93  *     3.4 Updating an address
  94  *
  95  *    The main purpose of address updates is to update the ATS
  96  *    information for addresse selection. Important for the proportional
  97  *    solver is when an address switches network it is located
  98  *    in. This is common because addresses added by transport's
  99  *    validation mechanism are commonly located in
 100  *    GNUNET_ATS_NET_UNSPECIFIED. Addresses in validation are located
 101  *    in this network type and only if a connection is successful on
 102  *    return of payload data transport switches to the real network
 103  *    the address is located in.  When an address changes networks it
 104  *    is first of all removed from the old network using the solver
 105  *    API function GAS_proportional_address_delete and the network in
 106  *    the address struct is updated. A lookup for the respective new
 107  *    proportional network is done and stored in the addresse's
 108  *    solver_information field. Next the address is re-added to the
 109  *    solver using the solver API function
 110  *    GAS_proportional_address_add. If the address was marked as in
 111  *    active, the solver checks if bandwidth is available in the
 112  *    network and if yes sets the address to active and updates the
 113  *    bandwidth distribution in this network. If no bandwidth is
 114  *    available it sets the bandwidth for this address to 0 and tries
 115  *    to suggest an alternative address. If an alternative address was
 116  *    found, addresses' callback is called for this address.
 117  *
 118  *     3.5 Deleting an address
 119  *
 120  *    When an address is removed from the solver, it removes the
 121  *    respective address from the network and if the address was
 122  *    marked as active, it updates the bandwidth distribution for this
 123  *    network.
 124  *
 125  *     3.6 Requesting addresses
 126  *
 127  *    When an address is requested for a peer the solver performs a
 128  *    lookup for the peer entry in addresses address hashmap and
 129  *    selects the best address.  The selection of the most suitable
 130  *    address is done in the find_address_it hashmap iterator
 131  *    described in detail in section 3.7. If no address is returned,
 132  *    no address can be suggested at the moment. If the address
 133  *    returned is marked as active, the solver can return this
 134  *    address. If the address is not marked as active, the solver
 135  *    checks if another address belongign to this peer is marked as
 136  *    active and marks the address as inactive, updates the bandwidth
 137  *    for this address to 0, call the bandwidth changed callback for
 138  *    this address due to the change and updates quota assignment for
 139  *    the addresse's network. the now in-active address is belonging
 140  *    to. The solver marks the new address as active and updates the
 141  *    bandwidth assignment for this network.
 142  *
 143  *     3.7 Choosing addresses
 144  *
 145  *    Choosing the best possible address for suggestion is done by
 146  *    iterating over all addresses of a peer stored in addresses'
 147  *    hashmap and using the hashmap iterator find_address_it to select
 148  *    the best available address.  Several checks are done when an
 149  *    address is selected. First if this address is currently blocked
 150  *    by addresses from being suggested. An address is blocked for the
 151  *    duration of ATS_BLOCKING_DELTA when it is suggested to
 152  *    transport. Next it is checked if at least
 153  *    GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT bytes bandwidth is available
 154  *    in the addresse's network, because suggesting an address without
 155  *    bandwidth does not make sense. This also ensures that all active
 156  *    addresses in this network get at least the minimum amount of
 157  *    bandwidth assigned. In the next step the solver ensures that for
 158  *    tcp connections inbound connections are prefered over outbound
 159  *    connections. In the next stet the solver ensures that
 160  *    connections are prefered in the following order: * connections
 161  *    are already established and have bandwidth assigned *
 162  *    connections with a shorter distance * connectes have a shorter
 163  *    latency
 164  *
 165  *     3.8 Changing preferences
 166  *
 167  *     3.9 Shutdown
 168  *
 169  *    During shutdown all network entries and aging processes are
 170  *    destroyed and freed.
 171  *
 172  *
 173  * OLD DOCUMENTATION
 174  *
 175  * This solver assigns in and outbound bandwidth equally for all
 176  * addresses in specific network type (WAN, LAN) based on configured
 177  * in and outbound quota for this network.
 178  *
 179  * The solver is notified by addresses about changes to the addresses
 180  * and recalculates the bandwith assigned if required. The solver
 181  * notifies addresses by calling the GAS_bandwidth_changed_cb
 182  * callback.
 183  *
 184  * - Initialization
 185  *
 186  *
 187  *
 188  *
 189  * For each peer only a single is selected and marked as "active" in the address
 190  * struct.
 191  *
 192  * E.g.:
 193  *
 194  * You have the networks WAN and LAN and quotas
 195  * WAN_TOTAL_IN, WAN_TOTAL_OUT
 196  * LAN_TOTAL_IN, LAN_TOTAL_OUT
 197  *
 198  * If you have x addresses in the network segment LAN, the quotas are
 199  * QUOTA_PER_ADDRESS = LAN_TOTAL_OUT / x
 200  *
 201  * Quotas are automatically recalculated and reported back when addresses are
 202  * - requested
 203  *
 204  */
 205
 206 #define PREF_AGING_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
 207 #define PREF_AGING_FACTOR 0.95
 208
 209 #define DEFAULT_REL_PREFERENCE 1.0
 210 #define DEFAULT_ABS_PREFERENCE 0.0
 211 #define MIN_UPDATE_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
 212
 213 /**
 214  * A handle for the proportional solver
 215  */
 216 struct GAS_PROPORTIONAL_Handle
 217 {
 218    struct GNUNET_ATS_PluginEnvironment *env;
 219
 220   /**
 221    * Statistics handle
 222    */
 223   struct GNUNET_STATISTICS_Handle *stats;
 224
 225   /**
 226    * Hashmap containing all valid addresses
 227    */
 228   const struct GNUNET_CONTAINER_MultiPeerMap *addresses;
 229
 230   /**
 231    * Pending address requests
 232    */
 233   struct GNUNET_CONTAINER_MultiPeerMap *requests;
 234
 235   /**
 236    * Bandwidth changed callback
 237    */
 238   GAS_bandwidth_changed_cb bw_changed;
 239
 240   /**
 241    * Bandwidth changed callback cls
 242    */
 243   void *bw_changed_cls;
 244
 245   /**
 246    * ATS function to get preferences
 247    */
 248   GAS_get_preferences get_preferences;
 249
 250   /**
 251    * Closure for ATS function to get preferences
 252    */
 253   void *get_preferences_cls;
 254
 255   /**
 256    * ATS function to get properties
 257    */
 258   GAS_get_properties get_properties;
 259
 260   /**
 261    * Closure for ATS function to get properties
 262    */
 263   void *get_properties_cls;
 264
 265   /**
 266    * Bulk lock
 267    */
 268   int bulk_lock;
 269
 270   /**
 271    * Number of changes while solver was locked
 272    */
 273   int bulk_requests;
 274
 275   /**
 276    * Total number of addresses for solver
 277    */
 278   unsigned int total_addresses;
 279
 280   /**
 281    * Number of active addresses for solver
 282    */
 283   unsigned int active_addresses;
 284
 285   /**
 286    * Networks array
 287    */
 288   struct Network *network_entries;
 289
 290   /**
 291    * Number of networks
 292    */
 293   unsigned int network_count;
 294
 295 };
 296
 297 /**
 298  * Representation of a network
 299  */
 300 struct Network
 301 {
 302   /**
 303    * ATS network type
 304    */
 305   unsigned int type;
 306
 307   /**
 308    * Network description
 309    */
 310   char *desc;
 311
 312   /**
 313    * Total inbound quota
 314    *
 315    */
 316   unsigned long long total_quota_in;
 317
 318   /**
 319    * Total outbound quota
 320    *
 321    */
 322   unsigned long long total_quota_out;
 323
 324   /**
 325    * Number of active addresses for this network
 326    */
 327   unsigned int active_addresses;
 328
 329   /**
 330    * Number of total addresses for this network
 331    */
 332   unsigned int total_addresses;
 333
 334   /**
 335    * String for statistics total addresses
 336    */
 337   char *stat_total;
 338
 339   /**
 340    * String for statistics active addresses
 341    */
 342   char *stat_active;
 343
 344   struct AddressWrapper *head;
 345   struct AddressWrapper *tail;
 346 };
 347
 348 /**
 349  * Wrapper for addresses to store them in network's linked list
 350  */
 351 struct AddressWrapper
 352 {
 353   /**
 354    * Next in DLL
 355    */
 356   struct AddressWrapper *next;
 357
 358   /**
 359    * Previous in DLL
 360    */
 361   struct AddressWrapper *prev;
 362
 363   /**
 364    * The address
 365    */
 366   struct ATS_Address *addr;
 367 };
 368
 369 /**
 370  *  Important solver functions
 371  *  ---------------------------
 372  */
 373
 374 void *
 375 libgnunet_plugin_ats_proportional_init (void *cls)
 376 {
 377   struct GNUNET_ATS_PluginEnvironment *env = cls;
 378   struct GAS_PROPORTIONAL_Handle *s;
 379   struct Network * cur;
 380   char * net_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
 381   int c;
 382
 383   GNUNET_assert (NULL != env);
 384   GNUNET_assert(NULL != env->cfg);
 385   GNUNET_assert(NULL != env->stats);
 386   GNUNET_assert(NULL != env->bandwidth_changed_cb);
 387   GNUNET_assert(NULL != env->get_preferences);
 388   GNUNET_assert(NULL != env->get_property);
 389
 390   s = GNUNET_malloc (sizeof (struct GAS_PROPORTIONAL_Handle));
 391   s->env = env;
 392   env->sf.s_add = &GAS_proportional_address_add;
 393   env->sf.s_address_update_property = &GAS_proportional_address_property_changed;
 394   env->sf.s_address_update_session = &GAS_proportional_address_session_changed;
 395   env->sf.s_address_update_inuse = &GAS_proportional_address_inuse_changed;
 396   env->sf.s_address_update_network = &GAS_proportional_address_change_network;
 397   env->sf.s_get = &GAS_proportional_get_preferred_address;
 398   env->sf.s_get_stop = &GAS_proportional_stop_get_preferred_address;
 399   env->sf.s_pref = &GAS_proportional_address_change_preference;
 400   env->sf.s_feedback = &GAS_proportional_address_preference_feedback;
 401   env->sf.s_del = &GAS_proportional_address_delete;
 402   env->sf.s_bulk_start = &GAS_proportional_bulk_start;
 403   env->sf.s_bulk_stop = &GAS_proportional_bulk_stop;
 404
 405   s->stats = (struct GNUNET_STATISTICS_Handle *) env->stats;
 406   s->bw_changed = env->bandwidth_changed_cb;
 407   s->bw_changed_cls = env->bw_changed_cb_cls;
 408   s->get_preferences = env->get_preferences;
 409   s->get_preferences_cls = env->get_preference_cls;
 410   s->get_properties = env->get_property;
 411   s->get_properties_cls = env->get_property_cls;
 412   s->network_count = env->network_count;
 413   s->network_entries = GNUNET_malloc (env->network_count * sizeof (struct Network));
 414
 415   /* Init */
 416   s->active_addresses = 0;
 417   s->total_addresses = 0;
 418   s->bulk_lock = GNUNET_NO;
 419   s->addresses = env->addresses;
 420   s->requests = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
 421
 422   for (c = 0; c < env->network_count; c++)
 423   {
 424     cur = &s->network_entries[c];
 425     cur->total_addresses = 0;
 426     cur->active_addresses = 0;
 427     cur->type = env->networks[c];
 428     cur->total_quota_in = env->in_quota[c];
 429     cur->total_quota_out = env->out_quota[c];
 430     cur->desc = net_str[c];
 431     GNUNET_asprintf (&cur->stat_total,
 432         "# ATS addresses %s total", cur->desc);
 433     GNUNET_asprintf (&cur->stat_active,
 434         "# ATS active addresses %s total", cur->desc);
 435     LOG (GNUNET_ERROR_TYPE_INFO, "Added network %u `%s' %p\n", c, cur->desc, s);
 436   }
 437   return s;
 438 }
 439
 440 void *
 441 libgnunet_plugin_ats_proportional_done (void *cls)
 442 {
 443   struct GAS_PROPORTIONAL_Handle *s = cls;
 444   struct AddressWrapper *cur;
 445   struct AddressWrapper *next;
 446   int c;
 447   GNUNET_assert(s != NULL);
 448   for (c = 0; c < s->network_count; c++)
 449   {
 450     if (s->network_entries[c].total_addresses > 0)
 451     {
 452       LOG(GNUNET_ERROR_TYPE_DEBUG,
 453           "Had %u addresses for network `%s' not deleted during shutdown\n",
 454           s->network_entries[c].total_addresses, s->network_entries[c].desc);
 455       GNUNET_break(0);
 456     }
 457
 458     if (s->network_entries[c].active_addresses > 0)
 459     {
 460       LOG(GNUNET_ERROR_TYPE_ERROR,
 461           "Had %u active addresses for network `%s' not deleted during shutdown\n",
 462           s->network_entries[c].active_addresses, s->network_entries[c].desc);
 463       GNUNET_break(0);
 464     }
 465
 466     next = s->network_entries[c].head;
 467     while (NULL != (cur = next))
 468     {
 469       next = cur->next;
 470       GNUNET_CONTAINER_DLL_remove(s->network_entries[c].head,
 471           s->network_entries[c].tail, cur);
 472       GNUNET_free(cur);
 473     }
 474     GNUNET_free(s->network_entries[c].stat_total);
 475     GNUNET_free(s->network_entries[c].stat_active);
 476   }
 477   if (s->total_addresses > 0)
 478   {
 479     LOG(GNUNET_ERROR_TYPE_ERROR,
 480         "Had %u addresses not deleted during shutdown\n", s->total_addresses);
 481     GNUNET_break(0);
 482   }
 483   if (s->active_addresses > 0)
 484   {
 485     LOG(GNUNET_ERROR_TYPE_ERROR,
 486         "Had %u active addresses not deleted during shutdown\n",
 487         s->active_addresses);
 488     GNUNET_break (0);
 489   }
 490   GNUNET_free (s->network_entries);
 491   GNUNET_CONTAINER_multipeermap_destroy (s->requests);
 492   GNUNET_free (s);
 493   return NULL;
 494 }
 495
 496
 497 /**
 498  * Test if bandwidth is available in this network to add an additional address
 499  *
 500  * @param net the network type to update
 501  * @return GNUNET_YES or GNUNET_NO
 502  */
 503 static int
 504 is_bandwidth_available_in_network (struct Network *net)
 505 {
 506   GNUNET_assert(NULL != net);
 507   unsigned int na = net->active_addresses + 1;
 508   uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
 509   if (((net->total_quota_in / na) > min_bw)
 510       && ((net->total_quota_out / na) > min_bw))
 511   {
 512     LOG(GNUNET_ERROR_TYPE_DEBUG,
 513         "Enough bandwidth available for %u active addresses in network `%s'\n",
 514         na, net->desc);
 515
 516     return GNUNET_YES;
 517   }
 518   LOG(GNUNET_ERROR_TYPE_DEBUG,
 519       "Not enough bandwidth available for %u active addresses in network `%s'\n",
 520       na, net->desc);
 521   return GNUNET_NO;
 522 }
 523
 524 /**
 525  * Update bandwidth assigned to peers in this network
 526  *
 527  * @param s the solver handle
 528  * @param net the network type to update
 529  * @param address_except address excluded from notification, since we suggest
 530  * this address
 531  */
 532 static void
 533 distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
 534     struct Network *net, struct ATS_Address *address_except)
 535 {
 536   unsigned long long remaining_quota_in = 0;
 537   unsigned long long quota_out_used = 0;
 538
 539   unsigned long long remaining_quota_out = 0;
 540   unsigned long long quota_in_used = 0;
 541   uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
 542   double peer_prefs;
 543   double total_prefs; /* Important: has to be double not float due to precision */
 544   double cur_pref; /* Important: has to be double not float due to precision */
 545   const double *t = NULL; /* Important: has to be double not float due to precision */
 546   int c;
 547
 548   unsigned long long assigned_quota_in = 0;
 549   unsigned long long assigned_quota_out = 0;
 550   struct AddressWrapper *cur;
 551
 552   LOG(GNUNET_ERROR_TYPE_DEBUG,
 553       "Recalculate quota for network type `%s' for %u addresses (in/out): %llu/%llu \n",
 554       net->desc, net->active_addresses, net->total_quota_in,
 555       net->total_quota_in);
 556
 557   if (net->active_addresses == 0)
 558     return; /* no addresses to update */
 559
 560   /* Idea
 561    * Assign every peer in network minimum Bandwidth
 562    * Distribute bandwidth left according to preference
 563    */
 564
 565   if ((net->active_addresses * min_bw) > net->total_quota_in)
 566   {
 567     GNUNET_break(0);
 568     return;
 569   }
 570   if ((net->active_addresses * min_bw) > net->total_quota_out)
 571   {
 572     GNUNET_break(0);
 573     return;
 574   }
 575
 576   remaining_quota_in = net->total_quota_in - (net->active_addresses * min_bw);
 577   remaining_quota_out = net->total_quota_out - (net->active_addresses * min_bw);
 578   LOG(GNUNET_ERROR_TYPE_DEBUG, "Remaining bandwidth : (in/out): %llu/%llu \n",
 579       remaining_quota_in, remaining_quota_out);
 580   total_prefs = 0.0;
 581   for (cur = net->head; NULL != cur; cur = cur->next)
 582   {
 583     if (GNUNET_YES == cur->addr->active)
 584     {
 585       GNUNET_assert(
 586           NULL != (t = s->get_preferences (s->get_preferences_cls, &cur->addr->peer)));
 587
 588       peer_prefs = 0.0;
 589       for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
 590       {
 591         if (c != GNUNET_ATS_PREFERENCE_END)
 592         {
 593           //fprintf (stderr, "VALUE[%u] %s %.3f \n", c, GNUNET_i2s (&cur->addr->peer), t[c]);
 594           peer_prefs += t[c];
 595         }
 596       }
 597       total_prefs += (peer_prefs / (GNUNET_ATS_PreferenceCount - 1));
 598     }
 599   }
 600   for (cur = net->head; NULL != cur; cur = cur->next)
 601   {
 602     if (GNUNET_YES == cur->addr->active)
 603     {
 604       cur_pref = 0.0;
 605       GNUNET_assert(
 606           NULL != (t = s->get_preferences (s->get_preferences_cls, &cur->addr->peer)));
 607
 608       for (c = 0; c < GNUNET_ATS_PreferenceCount; c++)
 609       {
 610         if (c != GNUNET_ATS_PREFERENCE_END)
 611           cur_pref += t[c];
 612       }
 613       cur_pref /= 2;
 614
 615       assigned_quota_in = min_bw
 616           + ((cur_pref / total_prefs) * remaining_quota_in);
 617       assigned_quota_out = min_bw
 618           + ((cur_pref / total_prefs) * remaining_quota_out);
 619
 620       LOG(GNUNET_ERROR_TYPE_DEBUG,
 621           "New quota for peer `%s' with preference (cur/total) %.3f/%.3f (in/out): %llu / %llu\n",
 622           GNUNET_i2s (&cur->addr->peer), cur_pref, total_prefs,
 623           assigned_quota_in, assigned_quota_out);
 624     }
 625     else
 626     {
 627       assigned_quota_in = 0;
 628       assigned_quota_out = 0;
 629     }
 630
 631     quota_in_used += assigned_quota_in;
 632     quota_out_used += assigned_quota_out;
 633     /* Prevent overflow due to rounding errors */
 634     if (assigned_quota_in > UINT32_MAX)
 635       assigned_quota_in = UINT32_MAX;
 636     if (assigned_quota_out > UINT32_MAX)
 637       assigned_quota_out = UINT32_MAX;
 638
 639     /* Compare to current bandwidth assigned */
 640     if ((assigned_quota_in != ntohl (cur->addr->assigned_bw_in.value__))
 641         || (assigned_quota_out != ntohl (cur->addr->assigned_bw_out.value__)))
 642     {
 643       cur->addr->assigned_bw_in.value__ = htonl (assigned_quota_in);
 644       cur->addr->assigned_bw_out.value__ = htonl (assigned_quota_out);
 645       /* Notify on change */
 646       if ((GNUNET_YES == cur->addr->active) && (cur->addr != address_except))
 647         s->bw_changed (s->bw_changed_cls, cur->addr);
 648     }
 649
 650   }
 651   LOG(GNUNET_ERROR_TYPE_DEBUG,
 652       "Total bandwidth assigned is (in/out): %llu /%llu\n", quota_in_used,
 653       quota_out_used);
 654   if (quota_out_used > net->total_quota_out + 1) /* +1 is required due to rounding errors */
 655   {
 656     LOG(GNUNET_ERROR_TYPE_ERROR,
 657         "Total outbound bandwidth assigned is larger than allowed (used/allowed) for %u active addresses: %llu / %llu\n",
 658         net->active_addresses, quota_out_used, net->total_quota_out);
 659   }
 660   if (quota_in_used > net->total_quota_in + 1) /* +1 is required due to rounding errors */
 661   {
 662     LOG(GNUNET_ERROR_TYPE_ERROR,
 663         "Total inbound bandwidth assigned is larger than allowed (used/allowed) for %u active addresses: %llu / %llu\n",
 664         net->active_addresses, quota_in_used, net->total_quota_in);
 665   }
 666 }
 667
 668 struct FindBestAddressCtx
 669 {
 670   struct GAS_PROPORTIONAL_Handle *s;
 671   struct ATS_Address *best;
 672 };
 673
 674 static int
 675 find_property_index (uint32_t type)
 676 {
 677   int existing_types[] = GNUNET_ATS_QualityProperties;
 678   int c;
 679   for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
 680     if (existing_types[c] == type)
 681       return c;
 682   return GNUNET_SYSERR;
 683 }
 684
 685 /**
 686  * Find a "good" address to use for a peer by iterating over the addresses for this peer.
 687  * If we already have an existing address, we stick to it.
 688  * Otherwise, we pick by lowest distance and then by lowest latency.
 689  *
 690  * @param cls the 'struct ATS_Address**' where we store the result
 691  * @param key unused
 692  * @param value another 'struct ATS_Address*' to consider using
 693  * @return GNUNET_OK (continue to iterate)
 694  */
 695 static int
 696 find_best_address_it (void *cls,
 697                       const struct GNUNET_PeerIdentity *key,
 698                       void *value)
 699 {
 700   struct FindBestAddressCtx *fba_ctx = (struct FindBestAddressCtx *) cls;
 701   struct ATS_Address *current = (struct ATS_Address *) value;
 702   struct GNUNET_TIME_Absolute now;
 703   struct Network *net = (struct Network *) current->solver_information;
 704   const double *norm_prop_cur;
 705   const double *norm_prop_prev;
 706   int index;
 707
 708   now = GNUNET_TIME_absolute_get ();
 709
 710   if (current->blocked_until.abs_value_us
 711       == GNUNET_TIME_absolute_max (now, current->blocked_until).abs_value_us)
 712   {
 713     /* This address is blocked for suggestion */
 714     LOG(GNUNET_ERROR_TYPE_DEBUG, "Address %p blocked for suggestion for %s \n",
 715         current,
 716         GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_difference (now, current->blocked_until), GNUNET_YES));
 717     return GNUNET_OK;
 718   }
 719   if (GNUNET_NO == is_bandwidth_available_in_network (net))
 720     return GNUNET_OK; /* There's no bandwidth available in this network */
 721   if (NULL != fba_ctx->best)
 722   {
 723     GNUNET_assert(NULL != fba_ctx->best->plugin);
 724     GNUNET_assert(NULL != current->plugin);
 725     if (0 == strcmp (fba_ctx->best->plugin, current->plugin))
 726     {
 727       if ((0 != fba_ctx->best->addr_len) && (0 == current->addr_len))
 728       {
 729         /* saved address was an outbound address, but we have an inbound address */
 730         fba_ctx->best = current;
 731         return GNUNET_OK;
 732       }
 733       if (0 == fba_ctx->best->addr_len)
 734       {
 735         /* saved address was an inbound address, so do not overwrite */
 736         return GNUNET_OK;
 737       }
 738     }
 739   }
 740   if (NULL == fba_ctx->best)
 741   {
 742     fba_ctx->best = current;
 743     return GNUNET_OK;
 744   }
 745   if ((ntohl (fba_ctx->best->assigned_bw_in.value__) == 0)
 746       && (ntohl (current->assigned_bw_in.value__) > 0))
 747   {
 748     /* stick to existing connection */
 749     fba_ctx->best = current;
 750     return GNUNET_OK;
 751   }
 752
 753   norm_prop_cur = fba_ctx->s->get_properties (fba_ctx->s->get_properties_cls,
 754       (const struct ATS_Address *) current);
 755   norm_prop_prev = fba_ctx->s->get_properties (fba_ctx->s->get_properties_cls,
 756       (const struct ATS_Address *) fba_ctx->best);
 757   /*
 758    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s previous %.2f current %.2f\n",
 759    "DISTANCE", norm_prop_cur[1], norm_prop_cur[1]);
 760    */
 761   index = find_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE);
 762   if (GNUNET_SYSERR == index)
 763   {
 764     GNUNET_break(0);
 765     return GNUNET_OK;
 766   }
 767   if (norm_prop_cur[index] < norm_prop_prev[index])
 768   {
 769     /* user shorter distance */
 770     fba_ctx->best = current;
 771     return GNUNET_OK;
 772   }
 773   /*
 774    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s previous %.2f current %.2f\n",
 775    "DELAY", norm_prop_cur[1], norm_prop_cur[1]);
 776    */
 777   index = find_property_index (GNUNET_ATS_QUALITY_NET_DELAY);
 778   if (GNUNET_SYSERR == index)
 779   {
 780     GNUNET_break(0);
 781     return GNUNET_OK;
 782   }
 783   if (norm_prop_cur[index] < norm_prop_prev[index])
 784   {
 785     /* user shorter delay */
 786     fba_ctx->best = current;
 787     return GNUNET_OK;
 788   }
 789
 790   /* don't care */
 791   return GNUNET_OK;
 792 }
 793
 794 /**
 795  *  Helper functions
 796  *  ---------------------------
 797  */
 798
 799 /**
 800  * Distribibute bandwidth
 801  *
 802  * @param s the solver handle
 803  * @param n the network, can be NULL for all network
 804  * @param address_except do not notify for this address
 805  */
 806
 807 static void distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s,
 808     struct Network *n,
 809     struct ATS_Address *address_except)
 810 {
 811   if (GNUNET_YES == s->bulk_lock)
 812   {
 813     s->bulk_requests++;
 814     return;
 815   }
 816
 817   if (NULL != n)
 818   {
 819     if (NULL != s->env->info_cb)
 820       s->env->info_cb (s->env->info_cb_cls, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
 821     distribute_bandwidth (s, n, address_except);
 822     if (NULL != s->env->info_cb)
 823       s->env->info_cb (s->env->info_cb_cls, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
 824   }
 825   else
 826   {
 827     int i;
 828     if (NULL != s->env->info_cb)
 829       s->env->info_cb (s->env->info_cb_cls, GAS_OP_SOLVE_START, GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
 830     for (i = 0; i < s->network_count; i++)
 831       distribute_bandwidth (s, &s->network_entries[i], NULL );
 832     if (NULL != s->env->info_cb)
 833       s->env->info_cb (s->env->info_cb_cls, GAS_OP_SOLVE_STOP, GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
 834   }
 835
 836 }
 837
 838 /**
 839  * Lookup network struct by type
 840  *
 841  * @param s the solver handle
 842  * @param type the network type
 843  * @return the network struct
 844  */
 845 static struct Network *
 846 get_network (struct GAS_PROPORTIONAL_Handle *s, uint32_t type)
 847 {
 848   int c;
 849   for (c = 0; c < s->network_count; c++)
 850   {
 851     if (s->network_entries[c].type == type)
 852       return &s->network_entries[c];
 853   }
 854   return NULL ;
 855 }
 856
 857 /**
 858  * Hashmap Iterator to find current active address for peer
 859  *
 860  * @param cls last active address
 861  * @param key peer's key
 862  * @param value address to check
 863  * @return #GNUNET_NO on double active address else #GNUNET_YES;
 864  */
 865 static int
 866 get_active_address_it (void *cls,
 867                        const struct GNUNET_PeerIdentity *key,
 868                        void *value)
 869 {
 870   struct ATS_Address **dest = cls;
 871   struct ATS_Address *aa = (struct ATS_Address *) value;
 872
 873   if (GNUNET_YES == aa->active)
 874   {
 875
 876     if (NULL != (*dest))
 877     {
 878       /* should never happen */
 879       LOG(GNUNET_ERROR_TYPE_ERROR, "Multiple active addresses for peer `%s'\n",
 880           GNUNET_i2s (&aa->peer));
 881       GNUNET_break(0);
 882       return GNUNET_NO;
 883     }
 884     (*dest) = aa;
 885   }
 886   return GNUNET_OK;
 887 }
 888
 889 /**
 890  * Find current active address for peer
 891  *
 892  * @param solver the solver handle
 893  * @param addresses the address set
 894  * @param peer the peer
 895  * @return active address or NULL
 896  */
 897 static struct ATS_Address *
 898 get_active_address (void *solver,
 899                     const struct GNUNET_CONTAINER_MultiPeerMap * addresses,
 900                     const struct GNUNET_PeerIdentity *peer)
 901 {
 902   struct ATS_Address * dest = NULL;
 903
 904   GNUNET_CONTAINER_multipeermap_get_multiple (addresses, peer,
 905                                               &get_active_address_it, &dest);
 906   return dest;
 907 }
 908
 909
 910 static void
 911 addresse_increment (struct GAS_PROPORTIONAL_Handle *s, struct Network *net,
 912     int total, int active)
 913 {
 914   if (GNUNET_YES == total)
 915   {
 916     s->total_addresses++;
 917     net->total_addresses++;
 918     GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", 1, GNUNET_NO);
 919     GNUNET_STATISTICS_update (s->stats, net->stat_total, 1, GNUNET_NO);
 920   }
 921   if (GNUNET_YES == active)
 922   {
 923     net->active_addresses++;
 924     s->active_addresses++;
 925     GNUNET_STATISTICS_update (s->stats, "# ATS active addresses total", 1,
 926         GNUNET_NO);
 927     GNUNET_STATISTICS_update (s->stats, net->stat_active, 1, GNUNET_NO);
 928   }
 929
 930 }
 931
 932
 933 static int
 934 addresse_decrement (struct GAS_PROPORTIONAL_Handle *s, struct Network *net,
 935     int total, int active)
 936 {
 937   int res = GNUNET_OK;
 938   if (GNUNET_YES == total)
 939   {
 940     if (s->total_addresses < 1)
 941     {
 942       GNUNET_break(0);
 943       res = GNUNET_SYSERR;
 944     }
 945     else
 946     {
 947       s->total_addresses--;
 948       GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", -1,
 949           GNUNET_NO);
 950     }
 951     if (net->total_addresses < 1)
 952     {
 953       GNUNET_break(0);
 954       res = GNUNET_SYSERR;
 955     }
 956     else
 957     {
 958       net->total_addresses--;
 959       GNUNET_STATISTICS_update (s->stats, net->stat_total, -1, GNUNET_NO);
 960     }
 961   }
 962
 963   if (GNUNET_YES == active)
 964   {
 965     if (net->active_addresses < 1)
 966     {
 967       GNUNET_break(0);
 968       res = GNUNET_SYSERR;
 969     }
 970     else
 971     {
 972       net->active_addresses--;
 973       GNUNET_STATISTICS_update (s->stats, net->stat_active, -1, GNUNET_NO);
 974     }
 975     if (s->active_addresses < 1)
 976     {
 977       GNUNET_break(0);
 978       res = GNUNET_SYSERR;
 979     }
 980     else
 981     {
 982       s->active_addresses--;
 983       GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", -1,
 984           GNUNET_NO);
 985     }
 986   }
 987   return res;
 988 }
 989
 990 /**
 991  *  Solver API functions
 992  *  ---------------------------
 993  */
 994
 995 /**
 996  * Changes the preferences for a peer in the problem
 997  *
 998  * @param solver the solver handle
 999  * @param peer the peer to change the preference for
1000  * @param kind the kind to change the preference
1001  * @param pref_rel the normalized preference value for this kind over all clients
1002  */
1003 void
1004 GAS_proportional_address_change_preference (void *solver,
1005                                             const struct GNUNET_PeerIdentity *peer,
1006                                             enum GNUNET_ATS_PreferenceKind kind,
1007                                             double pref_rel)
1008 {
1009   struct GAS_PROPORTIONAL_Handle *s = solver;
1010   GNUNET_assert(NULL != solver);
1011   GNUNET_assert(NULL != peer);
1012
1013   distribute_bandwidth_in_network (s, NULL, NULL);
1014 }
1015
1016
1017 /**
1018  * Get application feedback for a peer
1019  *
1020  * @param solver the solver handle
1021  * @param application the application
1022  * @param peer the peer to change the preference for
1023  * @param scope the time interval for this feedback: [now - scope .. now]
1024  * @param kind the kind to change the preference
1025  * @param score the score
1026  */
1027 void
1028 GAS_proportional_address_preference_feedback (void *solver, void *application,
1029     const struct GNUNET_PeerIdentity *peer,
1030     const struct GNUNET_TIME_Relative scope,
1031     enum GNUNET_ATS_PreferenceKind kind, double score)
1032 {
1033   struct GAS_PROPORTIONAL_Handle *s = solver;
1034   GNUNET_assert(NULL != solver);
1035   GNUNET_assert(NULL != peer);
1036
1037   GNUNET_assert(NULL != s);
1038   GNUNET_break(0);
1039 }
1040
1041 /**
1042  * Get the preferred address for a specific peer
1043  *
1044  * @param solver the solver handle
1045  * @param peer the identity of the peer
1046  */
1047 const struct ATS_Address *
1048 GAS_proportional_get_preferred_address (void *solver,
1049     const struct GNUNET_PeerIdentity *peer)
1050 {
1051   struct GAS_PROPORTIONAL_Handle *s = solver;
1052   struct Network *net_prev;
1053   struct Network *net_cur;
1054   struct ATS_Address *prev;
1055   struct FindBestAddressCtx fba_ctx;
1056
1057   GNUNET_assert(s != NULL);
1058   GNUNET_assert(peer != NULL);
1059
1060   /* Add to list of pending requests */
1061   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests,
1062                                                            peer))
1063   {
1064     GNUNET_assert (GNUNET_OK ==
1065                    GNUNET_CONTAINER_multipeermap_put (s->requests,
1066                                                       peer, NULL,
1067                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1068   }
1069
1070   /* Get address with: stick to current address, lower distance, lower latency */
1071   fba_ctx.s = s;
1072   fba_ctx.best = NULL;
1073
1074   GNUNET_CONTAINER_multipeermap_get_multiple (s->addresses, peer,
1075                                               &find_best_address_it, &fba_ctx);
1076   if (NULL == fba_ctx.best)
1077   {
1078     LOG(GNUNET_ERROR_TYPE_INFO, "Cannot suggest address for peer `%s'\n",
1079         GNUNET_i2s (peer));
1080     return NULL ;
1081   }
1082
1083   LOG(GNUNET_ERROR_TYPE_INFO, "Suggesting %s address %p for peer `%s'\n",
1084       (GNUNET_NO == fba_ctx.best->active) ? "inactive" : "active", fba_ctx.best,
1085       GNUNET_i2s (peer));
1086   net_cur = (struct Network *) fba_ctx.best->solver_information;
1087   if (NULL == fba_ctx.best)
1088   {
1089     LOG(GNUNET_ERROR_TYPE_ERROR,
1090         "Trying to suggesting unknown address peer `%s'\n", GNUNET_i2s (peer));
1091     GNUNET_break(0);
1092     return NULL ;
1093   }
1094   if (GNUNET_YES == fba_ctx.best->active)
1095   {
1096     /* This address was selected previously, so no need to update quotas */
1097     return fba_ctx.best;
1098   }
1099
1100   /* This address was not active, so we have to:
1101    *
1102    * - mark previous active address as not active
1103    * - update quota for previous address network
1104    * - update quota for this address network
1105    */
1106   prev = get_active_address (s, s->addresses, peer);
1107   if (NULL != prev)
1108   {
1109     net_prev = (struct Network *) prev->solver_information;
1110     prev->active = GNUNET_NO; /* No active any longer */
1111     prev->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1112     prev->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1113     if (GNUNET_SYSERR == addresse_decrement (s, net_prev, GNUNET_NO, GNUNET_YES))
1114       GNUNET_break(0);
1115     distribute_bandwidth_in_network (s, net_prev, NULL);
1116   }
1117
1118   if (GNUNET_NO == (is_bandwidth_available_in_network (fba_ctx.best->solver_information)))
1119   {
1120     GNUNET_break(0); /* This should never happen*/
1121     return NULL ;
1122   }
1123
1124   fba_ctx.best->active = GNUNET_YES;
1125   addresse_increment (s, net_cur, GNUNET_NO, GNUNET_YES);
1126   distribute_bandwidth_in_network (s, net_cur, fba_ctx.best);
1127   return fba_ctx.best;
1128 }
1129
1130 /**
1131  * Stop notifying about address and bandwidth changes for this peer
1132  *
1133  * @param solver the solver handle
1134  * @param peer the peer
1135  */
1136 void
1137 GAS_proportional_stop_get_preferred_address (void *solver,
1138     const struct GNUNET_PeerIdentity *peer)
1139 {
1140   struct GAS_PROPORTIONAL_Handle *s = solver;
1141   struct ATS_Address *cur;
1142   struct Network *cur_net;
1143
1144   if (GNUNET_YES
1145       == GNUNET_CONTAINER_multipeermap_contains (s->requests,
1146                                                  peer))
1147     GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (s->requests, peer,
1148                                           NULL));
1149
1150   cur = get_active_address (s,
1151                             s->addresses, peer);
1152   if (NULL != cur)
1153   {
1154     /* Disabling current address */
1155     cur_net = (struct Network *) cur->solver_information;
1156     cur->active = GNUNET_NO; /* No active any longer */
1157     cur->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1158     cur->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1159     if (GNUNET_SYSERR == addresse_decrement (s, cur_net, GNUNET_NO, GNUNET_YES))
1160       GNUNET_break(0);
1161     distribute_bandwidth_in_network (s, cur_net, NULL );
1162   }
1163   return;
1164 }
1165
1166 /**
1167  * Remove an address from the solver
1168  *
1169  * @param solver the solver handle
1170  * @param address the address to remove
1171  * @param session_only delete only session not whole address
1172  */
1173 void
1174 GAS_proportional_address_delete (void *solver, struct ATS_Address *address,
1175     int session_only)
1176 {
1177   struct GAS_PROPORTIONAL_Handle *s = solver;
1178   struct Network *net;
1179   struct AddressWrapper *aw;
1180   const struct ATS_Address *new_address;
1181
1182
1183   /* Remove an adress completely, we have to:
1184    * - Remove from specific network
1185    * - Decrease number of total addresses
1186    * - If active:
1187    *   - decrease number of active addreses
1188    *   - update quotas
1189    */
1190
1191   net = (struct Network *) address->solver_information;
1192
1193   if (GNUNET_NO == session_only)
1194   {
1195     LOG(GNUNET_ERROR_TYPE_INFO,
1196         "Deleting %s address %p for peer `%s' from network `%s' (total: %u/ active: %u)\n",
1197         (GNUNET_NO == address->active) ? "inactive" : "active", address,
1198         GNUNET_i2s (&address->peer), net->desc, net->total_addresses,
1199         net->active_addresses);
1200
1201     /* Remove address */
1202     addresse_decrement (s, net, GNUNET_YES, GNUNET_NO);
1203     for (aw = net->head; NULL != aw; aw = aw->next)
1204     {
1205       if (aw->addr == address)
1206         break;
1207     }
1208     if (NULL == aw)
1209     {
1210       GNUNET_break(0);
1211       return;
1212     }
1213     GNUNET_CONTAINER_DLL_remove(net->head, net->tail, aw);
1214     GNUNET_free(aw);
1215   }
1216   else
1217   {
1218     /* Remove session only: remove if active and update */
1219     LOG(GNUNET_ERROR_TYPE_INFO,
1220         "Deleting %s session %p for peer `%s' from network `%s' (total: %u/ active: %u)\n",
1221         (GNUNET_NO == address->active) ? "inactive" : "active", address,
1222         GNUNET_i2s (&address->peer), net->desc, net->total_addresses,
1223         net->active_addresses);
1224   }
1225
1226   if (GNUNET_YES == address->active)
1227   {
1228     /* Address was active, remove from network and update quotas*/
1229     address->active = GNUNET_NO;
1230     address->assigned_bw_in = BANDWIDTH_ZERO;
1231     address->assigned_bw_out = BANDWIDTH_ZERO;
1232
1233     if (GNUNET_SYSERR == addresse_decrement (s, net, GNUNET_NO, GNUNET_YES))
1234       GNUNET_break(0);
1235     distribute_bandwidth_in_network (s, net, NULL);
1236     if (NULL == (new_address = GAS_proportional_get_preferred_address (s, &address->peer)))
1237     {
1238       /* No alternative address found, disconnect peer */
1239       s->bw_changed (s->bw_changed_cls, address);
1240     }
1241     else
1242     {
1243       s->bw_changed (s->bw_changed_cls, (struct ATS_Address *) new_address);
1244     }
1245   }
1246   LOG(GNUNET_ERROR_TYPE_INFO,
1247       "After deleting address now total %u and active %u addresses in network `%s'\n",
1248       net->total_addresses, net->active_addresses, net->desc);
1249
1250 }
1251
1252 /**
1253  * Start a bulk operation
1254  *
1255  * @param solver the solver
1256  */
1257 void
1258 GAS_proportional_bulk_start (void *solver)
1259 {
1260   LOG(GNUNET_ERROR_TYPE_DEBUG, "Locking solver for bulk operation ...\n");
1261   struct GAS_PROPORTIONAL_Handle *s = (struct GAS_PROPORTIONAL_Handle *) solver;
1262
1263   GNUNET_assert(NULL != solver);
1264   s->bulk_lock++;
1265 }
1266
1267
1268 /**
1269  * Bulk operation done
1270  */
1271 void
1272 GAS_proportional_bulk_stop (void *solver)
1273 {
1274   LOG(GNUNET_ERROR_TYPE_DEBUG, "Unlocking solver from bulk operation ...\n");
1275
1276   struct GAS_PROPORTIONAL_Handle *s = (struct GAS_PROPORTIONAL_Handle *) solver;
1277   GNUNET_assert(NULL != solver);
1278
1279   if (s->bulk_lock < 1)
1280   {
1281     GNUNET_break(0);
1282     return;
1283   }
1284   s->bulk_lock--;
1285   if ((0 == s->bulk_lock) && (0 < s->bulk_requests))
1286   {
1287     LOG(GNUNET_ERROR_TYPE_DEBUG, "No lock pending, recalculating\n");
1288     distribute_bandwidth_in_network (s, NULL, NULL);
1289     s->bulk_requests = 0;
1290   }
1291 }
1292
1293
1294 /**
1295  * Add a new single address to a network
1296  *
1297  * @param solver the solver Handle
1298  * @param address the address to add
1299  * @param network network type of this address
1300  */
1301 void
1302 GAS_proportional_address_add (void *solver, struct ATS_Address *address,
1303     uint32_t network);
1304
1305 /**
1306  * Transport properties for this address have changed
1307  *
1308  * @param solver solver handle
1309  * @param address the address
1310  * @param type the ATSI type in HBO
1311  * @param abs_value the absolute value of the property
1312  * @param rel_value the normalized value
1313  */
1314 void
1315 GAS_proportional_address_property_changed (void *solver,
1316     struct ATS_Address *address, uint32_t type, uint32_t abs_value,
1317     double rel_value)
1318 {
1319   struct GAS_PROPORTIONAL_Handle *s;
1320   struct Network *n;
1321
1322   GNUNET_assert(NULL != solver);
1323   GNUNET_assert(NULL != address);
1324
1325   s = (struct GAS_PROPORTIONAL_Handle *) solver;
1326   n = (struct Network *) address->solver_information;
1327
1328   if (NULL == n)
1329   {
1330     GNUNET_break(0);
1331     return;
1332   }
1333
1334   LOG(GNUNET_ERROR_TYPE_DEBUG,
1335       "Property `%s' for peer `%s' address %p changed to %.2f \n",
1336       GNUNET_ATS_print_property_type (type), GNUNET_i2s (&address->peer),
1337       address, rel_value);
1338   switch (type)
1339   {
1340   case GNUNET_ATS_UTILIZATION_OUT:
1341   case GNUNET_ATS_UTILIZATION_IN:
1342   case GNUNET_ATS_UTILIZATION_PAYLOAD_IN:
1343   case GNUNET_ATS_UTILIZATION_PAYLOAD_OUT:
1344   case GNUNET_ATS_QUALITY_NET_DELAY:
1345   case GNUNET_ATS_QUALITY_NET_DISTANCE:
1346   case GNUNET_ATS_COST_WAN:
1347   case GNUNET_ATS_COST_LAN:
1348   case GNUNET_ATS_COST_WLAN:
1349     distribute_bandwidth_in_network (s, n, NULL);
1350     break;
1351   }
1352 }
1353
1354 /**
1355  * Transport session for this address has changed
1356  *
1357  * NOTE: values in addresses are already updated
1358  *
1359  * @param solver solver handle
1360  * @param address the address
1361  * @param cur_session the current session
1362  * @param new_session the new session
1363  */
1364 void
1365 GAS_proportional_address_session_changed (void *solver,
1366     struct ATS_Address *address, uint32_t cur_session, uint32_t new_session)
1367 {
1368   if (cur_session != new_session)
1369   {
1370     LOG(GNUNET_ERROR_TYPE_DEBUG, "Session changed from %u to %u\n", cur_session,
1371         new_session);
1372   }
1373 }
1374
1375 /**
1376  * Usage for this address has changed
1377  *
1378  * NOTE: values in addresses are already updated
1379  *
1380  * @param solver solver handle
1381  * @param address the address
1382  * @param in_use usage state
1383  */
1384 void
1385 GAS_proportional_address_inuse_changed (void *solver,
1386     struct ATS_Address *address, int in_use)
1387 {
1388   LOG(GNUNET_ERROR_TYPE_DEBUG, "Usage changed to %s\n",
1389       (GNUNET_YES == in_use) ? "USED" : "UNUSED");
1390 }
1391
1392 /**
1393  * Network scope for this address has changed
1394  *
1395  * NOTE: values in addresses are already updated
1396  *
1397  * @param solver solver handle
1398  * @param address the address
1399  * @param current_network the current network
1400  * @param new_network the new network
1401  */
1402 void
1403 GAS_proportional_address_change_network (void *solver,
1404     struct ATS_Address *address, uint32_t current_network, uint32_t new_network)
1405 {
1406   struct GAS_PROPORTIONAL_Handle *s = (struct GAS_PROPORTIONAL_Handle *) solver;
1407   int save_active = GNUNET_NO;
1408   struct Network *new_net = NULL;
1409
1410   if (current_network == new_network)
1411   {
1412     GNUNET_break(0);
1413     return;
1414   }
1415
1416   /* Network changed */
1417   LOG(GNUNET_ERROR_TYPE_DEBUG,
1418       "Network type changed, moving %s address from `%s' to `%s'\n",
1419       (GNUNET_YES == address->active) ? "active" : "inactive",
1420       GNUNET_ATS_print_network_type (current_network),
1421       GNUNET_ATS_print_network_type (new_network));
1422
1423   save_active = address->active;
1424
1425   /* Disable and assign no bandwidth */
1426   address->active = GNUNET_NO;
1427   address->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1428   address->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1429
1430   /* Remove from old network */
1431   GAS_proportional_address_delete (solver, address, GNUNET_NO);
1432
1433   /* Set new network type */
1434   if (NULL == (new_net = get_network (solver, new_network)))
1435   {
1436     /* Address changed to invalid network... */
1437     LOG(GNUNET_ERROR_TYPE_ERROR,
1438         _("Invalid network type `%u' `%s': Disconnect!\n"), new_network,
1439         GNUNET_ATS_print_network_type (new_network));
1440
1441     /* Find new address to suggest since no bandwidth in network*/
1442     if (NULL == GAS_proportional_get_preferred_address (s, &address->peer))
1443     {
1444       /* No alternative address found, disconnect peer */
1445       s->bw_changed (s->bw_changed_cls, address);
1446     }
1447     return;
1448   }
1449
1450   /* Add to new network and update*/
1451   address->solver_information = new_net;
1452   GAS_proportional_address_add (solver, address, new_network);
1453   if (GNUNET_YES == save_active)
1454   {
1455     /* check if bandwidth available in new network */
1456     if (GNUNET_YES == (is_bandwidth_available_in_network (new_net)))
1457     {
1458       /* Assign bandwidth to updated address */
1459       address->active = GNUNET_YES;
1460       addresse_increment (s, new_net, GNUNET_NO, GNUNET_YES);
1461       distribute_bandwidth_in_network (solver, new_net, NULL);
1462     }
1463     else
1464     {
1465       LOG(GNUNET_ERROR_TYPE_DEBUG,
1466           "Not enough bandwidth in new network, suggesting alternative address ..\n");
1467       /* Find new address to suggest since no bandwidth in network*/
1468       if (NULL == GAS_proportional_get_preferred_address (s, &address->peer))
1469       {
1470         /* No alternative address found, disconnect peer */
1471         s->bw_changed (s->bw_changed_cls, address);
1472       }
1473     }
1474   }
1475 }
1476
1477 /**
1478  * Add a new single address to a network
1479  *
1480  * @param solver the solver Handle
1481  * @param address the address to add
1482  * @param network network type of this address
1483  */
1484 void
1485 GAS_proportional_address_add (void *solver, struct ATS_Address *address,
1486     uint32_t network)
1487 {
1488   struct GAS_PROPORTIONAL_Handle *s = solver;
1489   struct Network *net = NULL;
1490   struct AddressWrapper *aw = NULL;
1491
1492   GNUNET_assert(NULL != s);
1493   net = get_network (s, network);
1494   if (NULL == net)
1495   {
1496     GNUNET_break(0);
1497     return;
1498   }
1499
1500   aw = GNUNET_malloc (sizeof (struct AddressWrapper));
1501   aw->addr = address;
1502   GNUNET_CONTAINER_DLL_insert(net->head, net->tail, aw);
1503   addresse_increment (s, net, GNUNET_YES, GNUNET_NO);
1504   aw->addr->solver_information = net;
1505
1506   if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1507   {
1508     if (NULL == get_active_address (s, s->addresses, &address->peer))
1509     {
1510       if (NULL != GAS_proportional_get_preferred_address (s, &address->peer))
1511           s->bw_changed (s->bw_changed_cls, (struct ATS_Address *) address);
1512     }
1513   }
1514
1515   LOG(GNUNET_ERROR_TYPE_INFO,
1516       "Adding new address %p for peer `%s', now total %u and active %u addresses in network `%s'\n",
1517       address, GNUNET_i2s(&address->peer), net->total_addresses, net->active_addresses, net->desc);
1518 }
1519
1520
1521 /* end of gnunet-service-ats-solver_proportional.c */