src/ats/plugin_ats_proportional.c

   1 /*
   2  This file is part of GNUnet.
   3  (C) 2011-2014 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/plugin_ats_proportional.c
  23  * @brief ATS proportional solver
  24  * @author Matthias Wachs
  25  * @author Christian Grothoff
  26  */
  27 #include "platform.h"
  28 #include "gnunet_statistics_service.h"
  29 #include "gnunet_ats_plugin.h"
  30 #include "gnunet-service-ats_addresses.h"
  31
  32 #define PROP_STABILITY_FACTOR 1.25
  33
  34
  35 #define LOG(kind,...) GNUNET_log_from (kind, "ats-proportional",__VA_ARGS__)
  36
  37
  38 /**
  39  *
  40  * NOTE: Do not change this documentation. This documentation is based
  41  * on gnunet.org:/vcs/fsnsg/ats-paper.git/tech-doku/ats-tech-guide.tex
  42  * use build_txt.sh to generate plaintext output
  43  *
  44  * ATS addresses : proportional solver
  45  *
  46  *    The proportional solver ("proportional") distributes the available
  47  *    bandwidth fair over all the addresses influenced by the
  48  *    preference values. For each available network type an in- and
  49  *    outbound quota is configured and the bandwidth available in
  50  *    these networks is distributed over the addresses.  The solver
  51  *    first assigns every addresses the minimum amount of bandwidth
  52  *    GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT and then distributes the
  53  *    remaining bandwidth available according to the preference
  54  *    values. For each peer only a single address gets bandwidth
  55  *    assigned and only one address marked as active.  The most
  56  *    important functionality for the solver is implemented in: *
  57  *    find_address_it is an hashmap iterator returning the prefered
  58  *    address for an peer * update_quota_per_network distributes
  59  *    available bandwidth for a network over active addresses
  60  *
  61  *    Changes to addresses automatically have an impact on the the
  62  *    bandwidth assigned to other addresses in the same network since
  63  *    the solver distributes the remaining bandwidth over the
  64  *    addresses in the network.  When changes to the addresses occur,
  65  *    the solver first performs the changes, like adding or deleting
  66  *    addresses, and then updates bandwidth assignment for the
  67  *    affected network. Bandwidth assignment is only recalculated on
  68  *    demand when an address is requested by a client for a peer or
  69  *    when the addresses available have changed or an address changed
  70  *    the network it is located in. When the bandwidth assignment has
  71  *    changed the callback is called with the new bandwidth
  72  *    assignments. The bandwidth distribution for a network is
  73  *    recalculated due to: * address suggestion requests * address
  74  *    deletions * address switching networks during address update *
  75  *    preference changes
  76  *
  77  *     3.1 Data structures used
  78  *
  79  *    For each ATS network (e.g. WAN, LAN, loopback) a struct Network
  80  *    is used to specify network related information as total adresses
  81  *    and active addresses in this network and the configured in- and
  82  *    outbound quota. Each network also contains a list of addresses
  83  *    added to the solver located in this network. The proportional
  84  *    solver uses the addresses' solver_information field to store the
  85  *    proportional network it belongs to for each address.
  86  *
  87  *     3.2 Initializing
  88  *
  89  *    When the proportional solver is initialized the solver creates a
  90  *    new solver handle and initializes the network structures with
  91  *    the quotas passed from addresses and returns the handle solver.
  92  *
  93  *     3.3 Adding an address
  94  *
  95  *    When a new address is added to the solver using s_add, a lookup
  96  *    for the network for this address is done and the address is
  97  *    enqueued in in the linked list of the network.
  98  *
  99  *     3.4 Updating an address
 100  *
 101  *    The main purpose of address updates is to update the ATS
 102  *    information for addresse selection. Important for the proportional
 103  *    solver is when an address switches network it is located
 104  *    in. This is common because addresses added by transport's
 105  *    validation mechanism are commonly located in
 106  *    GNUNET_ATS_NET_UNSPECIFIED. Addresses in validation are located
 107  *    in this network type and only if a connection is successful on
 108  *    return of payload data transport switches to the real network
 109  *    the address is located in.  When an address changes networks it
 110  *    is first of all removed from the old network using the solver
 111  *    API function #GAS_proportional_address_delete() and the network in
 112  *    the address struct is updated. A lookup for the respective new
 113  *    proportional network is done and stored in the addresse's
 114  *    solver_information field. Next the address is re-added to the
 115  *    solver using the solver API function
 116  *    #GAS_proportional_address_add(). If the address was marked as in
 117  *    active, the solver checks if bandwidth is available in the
 118  *    network and if yes sets the address to active and updates the
 119  *    bandwidth distribution in this network. If no bandwidth is
 120  *    available it sets the bandwidth for this address to 0 and tries
 121  *    to suggest an alternative address. If an alternative address was
 122  *    found, addresses' callback is called for this address.
 123  *
 124  *     3.5 Deleting an address
 125  *
 126  *    When an address is removed from the solver, it removes the
 127  *    respective address from the network and if the address was
 128  *    marked as active, it updates the bandwidth distribution for this
 129  *    network.
 130  *
 131  *     3.6 Requesting addresses
 132  *
 133  *    When an address is requested for a peer the solver performs a
 134  *    lookup for the peer entry in addresses address hashmap and
 135  *    selects the best address.  The selection of the most suitable
 136  *    address is done in the find_address_it hashmap iterator
 137  *    described in detail in section 3.7. If no address is returned,
 138  *    no address can be suggested at the moment. If the address
 139  *    returned is marked as active, the solver can return this
 140  *    address. If the address is not marked as active, the solver
 141  *    checks if another address belongign to this peer is marked as
 142  *    active and marks the address as inactive, updates the bandwidth
 143  *    for this address to 0, call the bandwidth changed callback for
 144  *    this address due to the change and updates quota assignment for
 145  *    the addresse's network. the now in-active address is belonging
 146  *    to. The solver marks the new address as active and updates the
 147  *    bandwidth assignment for this network.
 148  *
 149  *     3.7 Choosing addresses
 150  *
 151  *    Choosing the best possible address for suggestion is done by
 152  *    iterating over all addresses of a peer stored in addresses'
 153  *    hashmap and using the hashmap iterator find_address_it to select
 154  *    the best available address.  Several checks are done when an
 155  *    address is selected. First if this address is currently blocked
 156  *    by addresses from being suggested. An address is blocked for the
 157  *    duration of ATS_BLOCKING_DELTA when it is suggested to
 158  *    transport. Next it is checked if at least
 159  *    GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT bytes bandwidth is available
 160  *    in the addresse's network, because suggesting an address without
 161  *    bandwidth does not make sense. This also ensures that all active
 162  *    addresses in this network get at least the minimum amount of
 163  *    bandwidth assigned. In the next step the solver ensures that for
 164  *    tcp connections inbound connections are prefered over outbound
 165  *    connections. In the next stet the solver ensures that
 166  *    connections are prefered in the following order: * connections
 167  *    are already established and have bandwidth assigned *
 168  *    connections with a shorter distance * connectes have a shorter
 169  *    latency
 170  *
 171  *     3.8 Changing preferences
 172  *
 173  *     3.9 Shutdown
 174  *
 175  *    During shutdown all network entries and aging processes are
 176  *    destroyed and freed.
 177  *
 178  *
 179  * OLD DOCUMENTATION
 180  *
 181  * This solver assigns in and outbound bandwidth equally for all
 182  * addresses in specific network type (WAN, LAN) based on configured
 183  * in and outbound quota for this network.
 184  *
 185  * The solver is notified by addresses about changes to the addresses
 186  * and recalculates the bandwith assigned if required. The solver
 187  * notifies addresses by calling the GAS_bandwidth_changed_cb
 188  * callback.
 189  *
 190  * - Initialization
 191  *
 192  *
 193  *
 194  *
 195  * For each peer only a single is selected and marked as "active" in the address
 196  * struct.
 197  *
 198  * E.g.:
 199  *
 200  * You have the networks WAN and LAN and quotas
 201  * WAN_TOTAL_IN, WAN_TOTAL_OUT
 202  * LAN_TOTAL_IN, LAN_TOTAL_OUT
 203  *
 204  * If you have x addresses in the network segment LAN, the quotas are
 205  * QUOTA_PER_ADDRESS = LAN_TOTAL_OUT / x
 206  *
 207  * Quotas are automatically recalculated and reported back when addresses are
 208  * - requested
 209  *
 210  */
 211
 212 #define PROPORTIONALITY_FACTOR 2.0
 213
 214 /**
 215  * A handle for the proportional solver
 216  */
 217 struct GAS_PROPORTIONAL_Handle
 218 {
 219    struct GNUNET_ATS_PluginEnvironment *env;
 220
 221   /**
 222    * Statistics handle
 223    */
 224   struct GNUNET_STATISTICS_Handle *stats;
 225
 226   /**
 227    * Hashmap containing all valid addresses
 228    */
 229   struct GNUNET_CONTAINER_MultiPeerMap *addresses;
 230
 231   /**
 232    * Pending address requests
 233    */
 234   struct GNUNET_CONTAINER_MultiPeerMap *requests;
 235
 236   /**
 237    * Bandwidth changed callback
 238    */
 239   GAS_bandwidth_changed_cb bw_changed;
 240
 241   /**
 242    * Bandwidth changed callback cls
 243    */
 244   void *bw_changed_cls;
 245
 246   /**
 247    * ATS function to get preferences
 248    */
 249   GAS_get_preferences get_preferences;
 250
 251   /**
 252    * Closure for ATS function to get preferences
 253    */
 254   void *get_preferences_cls;
 255
 256   /**
 257    * ATS function to get properties
 258    */
 259   GAS_get_properties get_properties;
 260
 261   /**
 262    * Closure for ATS function to get properties
 263    */
 264   void *get_properties_cls;
 265
 266   /**
 267    * Bulk lock
 268    */
 269   int bulk_lock;
 270
 271   /**
 272    * Number of changes while solver was locked
 273    */
 274   int bulk_requests;
 275
 276   /**
 277    * Total number of addresses for solver
 278    */
 279   unsigned int total_addresses;
 280
 281   /**
 282    * Number of active addresses for solver
 283    */
 284   unsigned int active_addresses;
 285
 286   /**
 287    * Networks array
 288    */
 289   struct Network *network_entries;
 290
 291   /**
 292    * Number of networks
 293    */
 294   unsigned int network_count;
 295
 296   /**
 297    * Proportionality factor
 298    */
 299   double prop_factor;
 300
 301   /**
 302    * Stability factor
 303    */
 304   double stability_factor;
 305 };
 306
 307 /**
 308  * Representation of a network
 309  */
 310 struct Network
 311 {
 312   /**
 313    * ATS network type
 314    */
 315   unsigned int type;
 316
 317   /**
 318    * Network description
 319    */
 320   char *desc;
 321
 322   /**
 323    * Total inbound quota
 324    *
 325    */
 326   unsigned long long total_quota_in;
 327
 328   /**
 329    * Total outbound quota
 330    *
 331    */
 332   unsigned long long total_quota_out;
 333
 334   /**
 335    * Number of active addresses for this network
 336    */
 337   unsigned int active_addresses;
 338
 339   /**
 340    * Number of total addresses for this network
 341    */
 342   unsigned int total_addresses;
 343
 344   /**
 345    * String for statistics total addresses
 346    */
 347   char *stat_total;
 348
 349   /**
 350    * String for statistics active addresses
 351    */
 352   char *stat_active;
 353
 354   /**
 355    * FIXME.
 356    */
 357   struct AddressWrapper *head;
 358
 359   /**
 360    * FIXME.
 361    */
 362   struct AddressWrapper *tail;
 363 };
 364
 365 /**
 366  * Address information stored in the solver
 367  */
 368 struct AddressSolverInformation
 369 {
 370   struct Network *network;
 371
 372   /**
 373    * Inbound quota
 374    *
 375    */
 376   unsigned long long calculated_quota_in_NBO;
 377
 378   /**
 379    * Outbound quota
 380    *
 381    */
 382   unsigned long long calculated_quota_out_NBO;
 383
 384   /**
 385    * When was this address activated
 386    */
 387   struct GNUNET_TIME_Absolute activated;
 388
 389 };
 390
 391 /**
 392  * Wrapper for addresses to store them in network's linked list
 393  */
 394 struct AddressWrapper
 395 {
 396   /**
 397    * Next in DLL
 398    */
 399   struct AddressWrapper *next;
 400
 401   /**
 402    * Previous in DLL
 403    */
 404   struct AddressWrapper *prev;
 405
 406   /**
 407    * The address
 408    */
 409   struct ATS_Address *addr;
 410 };
 411
 412
 413 /**
 414  * Function used to unload the plugin.
 415  *
 416  * @param cls return value from #libgnunet_plugin_ats_proportional_init()
 417  */
 418 void *
 419 libgnunet_plugin_ats_proportional_done (void *cls)
 420 {
 421   struct GAS_PROPORTIONAL_Handle *s = cls;
 422   struct AddressWrapper *cur;
 423   struct AddressWrapper *next;
 424   int c;
 425
 426   GNUNET_assert(s != NULL);
 427   for (c = 0; c < s->network_count; c++)
 428   {
 429     if (s->network_entries[c].total_addresses > 0)
 430     {
 431       LOG(GNUNET_ERROR_TYPE_DEBUG,
 432           "Had %u addresses for network `%s' not deleted during shutdown\n",
 433           s->network_entries[c].total_addresses, s->network_entries[c].desc);
 434       //GNUNET_break(0);
 435     }
 436
 437     if (s->network_entries[c].active_addresses > 0)
 438     {
 439       LOG(GNUNET_ERROR_TYPE_DEBUG,
 440           "Had %u active addresses for network `%s' not deleted during shutdown\n",
 441           s->network_entries[c].active_addresses, s->network_entries[c].desc);
 442       //GNUNET_break(0);
 443     }
 444
 445     next = s->network_entries[c].head;
 446     while (NULL != (cur = next))
 447     {
 448       next = cur->next;
 449       GNUNET_CONTAINER_DLL_remove(s->network_entries[c].head,
 450           s->network_entries[c].tail, cur);
 451       GNUNET_free_non_null (cur->addr->solver_information);
 452       GNUNET_free(cur);
 453     }
 454     GNUNET_free(s->network_entries[c].stat_total);
 455     GNUNET_free(s->network_entries[c].stat_active);
 456   }
 457   if (s->total_addresses > 0)
 458   {
 459     LOG(GNUNET_ERROR_TYPE_DEBUG,
 460         "Had %u addresses not deleted during shutdown\n", s->total_addresses);
 461     // GNUNET_break(0);
 462   }
 463   if (s->active_addresses > 0)
 464   {
 465     LOG(GNUNET_ERROR_TYPE_DEBUG,
 466         "Had %u active addresses not deleted during shutdown\n",
 467         s->active_addresses);
 468     // GNUNET_break (0);
 469   }
 470   GNUNET_free (s->network_entries);
 471   GNUNET_CONTAINER_multipeermap_destroy (s->requests);
 472   GNUNET_free (s);
 473   return NULL;
 474 }
 475
 476
 477 /**
 478  * Test if bandwidth is available in this network to add an additional address
 479  *
 480  * @param net the network type to update
 481  * @return #GNUNET_YES or #GNUNET_NO
 482  */
 483 static int
 484 is_bandwidth_available_in_network (struct Network *net)
 485 {
 486   GNUNET_assert(NULL != net);
 487   unsigned int na = net->active_addresses + 1;
 488   uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
 489   if (((net->total_quota_in / na) > min_bw)
 490       && ((net->total_quota_out / na) > min_bw))
 491   {
 492     LOG(GNUNET_ERROR_TYPE_DEBUG,
 493         "Enough bandwidth available for %u active addresses in network `%s'\n",
 494         na, net->desc);
 495
 496     return GNUNET_YES;
 497   }
 498   LOG(GNUNET_ERROR_TYPE_DEBUG,
 499       "Not enough bandwidth available for %u active addresses in network `%s'\n",
 500       na, net->desc);
 501   return GNUNET_NO;
 502 }
 503
 504
 505 /**
 506  * Update bandwidth assigned to peers in this network
 507  *
 508  * @param s the solver handle
 509  * @param net the network type to update
 510  * this address
 511  */
 512 static void
 513 distribute_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
 514     struct Network *net)
 515 {
 516   struct AddressSolverInformation *asi;
 517   struct AddressWrapper *cur_address;
 518
 519   unsigned long long remaining_quota_in = 0;
 520   unsigned long long quota_out_used = 0;
 521   unsigned long long remaining_quota_out = 0;
 522   unsigned long long quota_in_used = 0;
 523   int count_addresses;
 524   uint32_t min_bw = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
 525   double relative_peer_prefence;
 526   double sum_relative_peer_prefences; /* Important: has to be double not float due to precision */
 527   double cur_pref; /* Important: has to be double not float due to precision */
 528   double peer_weight;
 529   double total_weight;
 530   const double *peer_relative_prefs = NULL; /* Important: has to be double not float due to precision */
 531
 532   unsigned long long assigned_quota_in = 0;
 533   unsigned long long assigned_quota_out = 0;
 534
 535
 536   LOG(GNUNET_ERROR_TYPE_INFO,
 537       "Recalculate quota for network type `%s' for %u addresses (in/out): %llu/%llu \n",
 538       net->desc, net->active_addresses, net->total_quota_in,
 539       net->total_quota_in);
 540
 541   if (net->active_addresses == 0)
 542   {
 543     return; /* no addresses to update */
 544   }
 545
 546   /* Idea
 547    * Assign every peer in network minimum Bandwidth
 548    * Distribute bandwidth left according to preference
 549    */
 550
 551   if ((net->active_addresses * min_bw) > net->total_quota_in)
 552   {
 553     GNUNET_break(0);
 554     return;
 555   }
 556   if ((net->active_addresses * min_bw) > net->total_quota_out)
 557   {
 558     GNUNET_break(0);
 559     return;
 560   }
 561
 562   remaining_quota_in = net->total_quota_in - (net->active_addresses * min_bw);
 563   remaining_quota_out = net->total_quota_out - (net->active_addresses * min_bw);
 564   LOG(GNUNET_ERROR_TYPE_DEBUG, "Remaining bandwidth : (in/out): %llu/%llu \n",
 565       remaining_quota_in, remaining_quota_out);
 566   sum_relative_peer_prefences = 0.0;
 567
 568   /* Calculate sum of relative preference for active addresses in this network */
 569   count_addresses = 0;
 570   for (cur_address = net->head; NULL != cur_address; cur_address = cur_address->next)
 571   {
 572     if (GNUNET_YES != cur_address->addr->active)
 573       continue;
 574
 575     GNUNET_assert( NULL != (peer_relative_prefs = s->get_preferences (s->get_preferences_cls,
 576         &cur_address->addr->peer)));
 577     relative_peer_prefence = 0.0;
 578     relative_peer_prefence += peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
 579     sum_relative_peer_prefences += relative_peer_prefence;
 580     count_addresses ++;
 581   }
 582
 583   if (count_addresses != net->active_addresses)
 584   {
 585     GNUNET_break (0);
 586     LOG(GNUNET_ERROR_TYPE_WARNING,
 587         "%s: Counted %u active addresses, but network says to have %u active addresses \n",
 588         net->desc, count_addresses, net->active_addresses);
 589     for (cur_address = net->head; NULL != cur_address; cur_address = cur_address->next)
 590     {
 591       if (GNUNET_YES != cur_address->addr->active)
 592         continue;
 593
 594       LOG (GNUNET_ERROR_TYPE_WARNING, "Active: `%s' `%s' length %u\n",
 595           GNUNET_i2s (&cur_address->addr->peer), cur_address->addr->plugin,
 596           cur_address->addr->addr_len);
 597     }
 598   }
 599
 600   LOG (GNUNET_ERROR_TYPE_INFO,
 601       "Total relative preference %.3f for %u addresses in network %s\n",
 602       sum_relative_peer_prefences, net->active_addresses, net->desc);
 603
 604   for (cur_address = net->head; NULL != cur_address; cur_address = cur_address->next)
 605   {
 606     if (GNUNET_YES == cur_address->addr->active)
 607     {
 608       GNUNET_assert( NULL != (peer_relative_prefs =
 609           s->get_preferences (s->get_preferences_cls, &cur_address->addr->peer)));
 610
 611       cur_pref = peer_relative_prefs[GNUNET_ATS_PREFERENCE_BANDWIDTH];
 612       total_weight = net->active_addresses +
 613           s->prop_factor * sum_relative_peer_prefences;
 614       peer_weight = (1.0 + (s->prop_factor * cur_pref));
 615
 616       assigned_quota_in = min_bw
 617           + ((peer_weight / total_weight) * remaining_quota_in);
 618       assigned_quota_out = min_bw
 619           + ((peer_weight / total_weight) * remaining_quota_out);
 620
 621       LOG (GNUNET_ERROR_TYPE_INFO,
 622           "New quota for peer `%s' with weight (cur/total) %.3f/%.3f (in/out): %llu / %llu\n",
 623           GNUNET_i2s (&cur_address->addr->peer), peer_weight, total_weight,
 624           assigned_quota_in, assigned_quota_out);
 625     }
 626     else
 627     {
 628       assigned_quota_in = 0;
 629       assigned_quota_out = 0;
 630     }
 631
 632     quota_in_used += assigned_quota_in;
 633     quota_out_used += assigned_quota_out;
 634     /* Prevent overflow due to rounding errors */
 635     if (assigned_quota_in > UINT32_MAX)
 636       assigned_quota_in = UINT32_MAX;
 637     if (assigned_quota_out > UINT32_MAX)
 638       assigned_quota_out = UINT32_MAX;
 639
 640     /* Compare to current bandwidth assigned */
 641     asi = cur_address->addr->solver_information;
 642     asi->calculated_quota_in_NBO = htonl (assigned_quota_in);
 643     asi->calculated_quota_out_NBO = htonl (assigned_quota_out);
 644   }
 645   LOG(GNUNET_ERROR_TYPE_DEBUG,
 646       "Total bandwidth assigned is (in/out): %llu /%llu\n", quota_in_used,
 647       quota_out_used);
 648   if (quota_out_used > net->total_quota_out + 1) /* +1 is required due to rounding errors */
 649   {
 650     LOG(GNUNET_ERROR_TYPE_ERROR,
 651         "Total outbound bandwidth assigned is larger than allowed (used/allowed) for %u active addresses: %llu / %llu\n",
 652         net->active_addresses, quota_out_used, net->total_quota_out);
 653   }
 654   if (quota_in_used > net->total_quota_in + 1) /* +1 is required due to rounding errors */
 655   {
 656     LOG(GNUNET_ERROR_TYPE_ERROR,
 657         "Total inbound bandwidth assigned is larger than allowed (used/allowed) for %u active addresses: %llu / %llu\n",
 658         net->active_addresses, quota_in_used, net->total_quota_in);
 659   }
 660 }
 661
 662
 663 /**
 664  * FIXME.
 665  */
 666 struct FindBestAddressCtx
 667 {
 668   struct GAS_PROPORTIONAL_Handle *s;
 669   struct ATS_Address *best;
 670 };
 671
 672
 673 /**
 674  * FIXME.
 675  */
 676 static int
 677 find_property_index (uint32_t type)
 678 {
 679   int existing_types[] = GNUNET_ATS_QualityProperties;
 680   int c;
 681
 682   for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
 683     if (existing_types[c] == type)
 684       return c;
 685   return GNUNET_SYSERR;
 686 }
 687
 688
 689 /**
 690  * Find a "good" address to use for a peer by iterating over the addresses for this peer.
 691  * If we already have an existing address, we stick to it.
 692  * Otherwise, we pick by lowest distance and then by lowest latency.
 693  *
 694  * @param cls the `struct FindBestAddressCtx *' where we store the result
 695  * @param key unused
 696  * @param value another `struct ATS_Address*` to consider using
 697  * @return #GNUNET_OK (continue to iterate)
 698  */
 699 static int
 700 find_best_address_it (void *cls,
 701                       const struct GNUNET_PeerIdentity *key,
 702                       void *value)
 703 {
 704   struct FindBestAddressCtx *ctx = cls;
 705   struct ATS_Address *current = value;
 706   struct ATS_Address *current_best = current;
 707   struct GNUNET_TIME_Absolute now;
 708   struct AddressSolverInformation *asi;
 709   struct GNUNET_TIME_Relative active_time;
 710   struct GNUNET_TIME_Relative min_active_time;
 711   const double *norm_prop_cur;
 712   const double *norm_prop_best;
 713   double best_delay;
 714   double best_distance;
 715   double cur_delay;
 716   double cur_distance;
 717   int index;
 718
 719   current_best = NULL;
 720   asi = current->solver_information;
 721   now = GNUNET_TIME_absolute_get ();
 722
 723   if ((current->active == GNUNET_NO)
 724       && (current->blocked_until.abs_value_us
 725           == GNUNET_TIME_absolute_max (now, current->blocked_until).abs_value_us))
 726   {
 727     /* This address is blocked for suggestion */
 728     LOG (GNUNET_ERROR_TYPE_DEBUG,
 729          "Address %p blocked for suggestion for %s \n",
 730          current,
 731          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_difference (now, current->blocked_until),
 732                                                  GNUNET_YES));
 733     return GNUNET_OK;
 734   }
 735   if (NULL == asi)
 736   {
 737     GNUNET_break (0);
 738     return GNUNET_OK;
 739   }
 740
 741   if (GNUNET_NO == is_bandwidth_available_in_network (asi->network))
 742   {
 743     return GNUNET_OK; /* There's no bandwidth available in this network */
 744   }
 745
 746   if (NULL != ctx->best)
 747   {
 748     /* Compare current addresses with denominated 'best' address */
 749     current_best = ctx->best;
 750   }
 751   else
 752   {
 753     /* We do not have a 'best' address so take this address */
 754     LOG (GNUNET_ERROR_TYPE_DEBUG,
 755          "Setting initial address %p\n",
 756          current);
 757     current_best = current;
 758     goto end;
 759   }
 760
 761   if (GNUNET_YES == current->active)
 762   {
 763     GNUNET_assert (asi->activated.abs_value_us != GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us);
 764     active_time = GNUNET_TIME_absolute_get_duration (asi->activated);
 765     min_active_time.rel_value_us =  ((double) GNUNET_TIME_UNIT_SECONDS.rel_value_us) *
 766         PROP_STABILITY_FACTOR;
 767     if (active_time.rel_value_us <= min_active_time.rel_value_us)
 768     {
 769       /* Keep active address for stability reasons */
 770       ctx->best = current;
 771       return GNUNET_NO;
 772     }
 773   }
 774
 775   /* Now compare ATS information */
 776   norm_prop_cur = ctx->s->get_properties (ctx->s->get_properties_cls,
 777       (const struct ATS_Address *) current);
 778   index = find_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE);
 779   cur_distance = norm_prop_cur[index];
 780   index = find_property_index (GNUNET_ATS_QUALITY_NET_DELAY);
 781   cur_delay = norm_prop_cur[index];
 782
 783   norm_prop_best = ctx->s->get_properties (ctx->s->get_properties_cls,
 784       (const struct ATS_Address *) ctx->best);
 785   index = find_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE);
 786   best_distance = norm_prop_best[index];
 787   index = find_property_index (GNUNET_ATS_QUALITY_NET_DELAY);
 788   best_delay = norm_prop_best[index];
 789
 790   /* user shorter distance */
 791   if (cur_distance < best_distance)
 792   {
 793
 794     if (GNUNET_NO == ctx->best->active)
 795     {
 796       current_best = current; /* Use current */
 797     }
 798     else if ((best_distance / cur_distance) > ctx->s->stability_factor)
 799     {
 800       /* Best and active address performs worse  */
 801       current_best = current;
 802     }
 803   }
 804   else
 805   {
 806     /* Use current best */
 807     current_best = ctx->best;
 808   }
 809
 810   /* User connection with less delay */
 811   if (cur_delay < best_delay)
 812   {
 813
 814     if (GNUNET_NO == ctx->best->active)
 815     {
 816       current_best = current; /* Use current */
 817     }
 818     else if ((best_delay / cur_delay) > ctx->s->stability_factor)
 819     {
 820       /* Best and active address performs worse  */
 821       current_best = current;
 822     }
 823   }
 824   else
 825   {
 826     /* Use current best */
 827     current_best = ctx->best;
 828   }
 829
 830 end:
 831   ctx->best = current_best;
 832   return GNUNET_OK;
 833 }
 834
 835
 836 /**
 837  * Find the currently best address for a peer from the set of addresses available
 838  * or return NULL of no address is available
 839  *
 840  * @param s the proportional handle
 841  * @param addresses the address hashmap
 842  * @param id the peer id
 843  * @return the address or NULL
 844  */
 845 struct ATS_Address *
 846 get_best_address (struct GAS_PROPORTIONAL_Handle *s,
 847                   struct GNUNET_CONTAINER_MultiPeerMap *addresses,
 848                   const struct GNUNET_PeerIdentity *id)
 849 {
 850   struct FindBestAddressCtx fba_ctx;
 851
 852   fba_ctx.best = NULL;
 853   fba_ctx.s = s;
 854   GNUNET_CONTAINER_multipeermap_get_multiple (addresses, id,
 855                                               &find_best_address_it, &fba_ctx);
 856
 857   return fba_ctx.best;
 858 }
 859
 860
 861 /**
 862  * Hashmap Iterator to find current active address for peer
 863  *
 864  * @param cls last active address
 865  * @param key peer's key
 866  * @param value address to check
 867  * @return #GNUNET_NO on double active address else #GNUNET_YES;
 868  */
 869 static int
 870 get_active_address_it (void *cls,
 871                        const struct GNUNET_PeerIdentity *key,
 872                        void *value)
 873 {
 874   struct ATS_Address **dest = cls;
 875   struct ATS_Address *aa = (struct ATS_Address *) value;
 876
 877   if (GNUNET_YES == aa->active)
 878   {
 879
 880     if (NULL != (*dest))
 881     {
 882       /* should never happen */
 883       LOG (GNUNET_ERROR_TYPE_ERROR,
 884            "Multiple active addresses for peer `%s'\n",
 885            GNUNET_i2s (&aa->peer));
 886       GNUNET_break(0);
 887       return GNUNET_NO;
 888     }
 889     (*dest) = aa;
 890   }
 891   return GNUNET_OK;
 892 }
 893
 894
 895 /**
 896  * Find current active address for peer
 897  *
 898  * @param solver the solver handle
 899  * @param addresses the address set
 900  * @param peer the peer
 901  * @return active address or NULL
 902  */
 903 static struct ATS_Address *
 904 get_active_address (void *solver,
 905                     const struct GNUNET_CONTAINER_MultiPeerMap * addresses,
 906                     const struct GNUNET_PeerIdentity *peer)
 907 {
 908   static struct ATS_Address * dest = NULL;
 909
 910   dest = NULL;
 911   GNUNET_CONTAINER_multipeermap_get_multiple (addresses, peer,
 912                                               &get_active_address_it, &dest);
 913   return dest;
 914 }
 915
 916
 917 /**
 918  * Lookup network struct by type
 919  *
 920  * @param s the solver handle
 921  * @param type the network type
 922  * @return the network struct
 923  */
 924 static struct Network *
 925 get_network (struct GAS_PROPORTIONAL_Handle *s, uint32_t type)
 926 {
 927   int c;
 928   for (c = 0; c < s->network_count; c++)
 929   {
 930     if (s->network_entries[c].type == type)
 931       return &s->network_entries[c];
 932   }
 933   return NULL ;
 934 }
 935
 936
 937 /**
 938  * Increase address count in network
 939  *
 940  * @param s the solver handle
 941  * @param net the network type
 942  * @param total increase total addresses
 943  * @param active increase active addresses
 944  */
 945 static void
 946 address_increment (struct GAS_PROPORTIONAL_Handle *s,
 947                     struct Network *net,
 948                     int total,
 949                     int active)
 950 {
 951   if (GNUNET_YES == total)
 952   {
 953     s->total_addresses++;
 954     net->total_addresses++;
 955     GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", 1, GNUNET_NO);
 956     GNUNET_STATISTICS_update (s->stats, net->stat_total, 1, GNUNET_NO);
 957   }
 958   if (GNUNET_YES == active)
 959   {
 960     net->active_addresses++;
 961     s->active_addresses++;
 962     GNUNET_STATISTICS_update (s->stats, "# ATS active addresses total", 1,
 963         GNUNET_NO);
 964     GNUNET_STATISTICS_update (s->stats, net->stat_active, 1, GNUNET_NO);
 965   }
 966
 967 }
 968
 969
 970 /**
 971  * Decrease address count in network
 972  *
 973  * @param s the solver handle
 974  * @param net the network type
 975  * @param total decrease total addresses
 976  * @param active decrease active addresses
 977  */
 978 static int
 979 addresse_decrement (struct GAS_PROPORTIONAL_Handle *s,
 980                     struct Network *net,
 981                     int total,
 982                     int active)
 983 {
 984   int res = GNUNET_OK;
 985
 986   if (GNUNET_YES == total)
 987   {
 988     if (s->total_addresses < 1)
 989     {
 990       GNUNET_break(0);
 991       res = GNUNET_SYSERR;
 992     }
 993     else
 994     {
 995       s->total_addresses--;
 996       GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", -1,
 997           GNUNET_NO);
 998     }
 999     if (net->total_addresses < 1)
1000     {
1001       GNUNET_break(0);
1002       res = GNUNET_SYSERR;
1003     }
1004     else
1005     {
1006       net->total_addresses--;
1007       GNUNET_STATISTICS_update (s->stats, net->stat_total, -1, GNUNET_NO);
1008     }
1009   }
1010
1011   if (GNUNET_YES == active)
1012   {
1013     if (net->active_addresses < 1)
1014     {
1015       GNUNET_break(0);
1016       res = GNUNET_SYSERR;
1017     }
1018     else
1019     {
1020       net->active_addresses--;
1021       GNUNET_STATISTICS_update (s->stats, net->stat_active, -1, GNUNET_NO);
1022     }
1023     if (s->active_addresses < 1)
1024     {
1025       GNUNET_break(0);
1026       res = GNUNET_SYSERR;
1027     }
1028     else
1029     {
1030       s->active_addresses--;
1031       GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", -1,
1032           GNUNET_NO);
1033     }
1034   }
1035   return res;
1036 }
1037
1038
1039 /**
1040  * FIXME.
1041  */
1042 static int
1043 address_eq (struct ATS_Address *a, struct ATS_Address *b)
1044 {
1045   GNUNET_assert (NULL != a);
1046   GNUNET_assert (NULL != b);
1047   if (0 != strcmp(a->plugin, b->plugin))
1048     return GNUNET_NO;
1049   if (a->addr_len != b->addr_len)
1050     return GNUNET_NO;
1051   if (0 != memcmp (a->addr, b->addr, b->addr_len))
1052     return GNUNET_NO;
1053   if (a->session_id != b->session_id)
1054     return GNUNET_NO;
1055   return GNUNET_YES;
1056 }
1057
1058
1059 /**
1060  * FIXME.
1061  */
1062 static void
1063 propagate_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
1064                      struct Network *net)
1065 {
1066   struct AddressWrapper *cur;
1067   struct AddressSolverInformation *asi;
1068   for (cur = net->head; NULL != cur; cur = cur->next)
1069   {
1070       asi = cur->addr->solver_information;
1071       if ( (cur->addr->assigned_bw_in.value__ != asi->calculated_quota_in_NBO) ||
1072            (cur->addr->assigned_bw_out.value__ != asi->calculated_quota_out_NBO) )
1073       {
1074         cur->addr->assigned_bw_in.value__ = asi->calculated_quota_in_NBO;
1075         cur->addr->assigned_bw_out.value__ = asi->calculated_quota_out_NBO;
1076
1077         /* Reset for next iteration */
1078         asi->calculated_quota_in_NBO = htonl (0);
1079         asi->calculated_quota_out_NBO = htonl (0);
1080
1081         LOG (GNUNET_ERROR_TYPE_DEBUG,
1082             "Bandwidth for %s address %p for peer `%s' changed to %u/%u\n",
1083             (GNUNET_NO == cur->addr->active) ? "inactive" : "active",
1084             cur->addr,
1085             GNUNET_i2s (&cur->addr->peer),
1086             ntohl (cur->addr->assigned_bw_in.value__),
1087             ntohl (cur->addr->assigned_bw_out.value__ ));
1088
1089         /* Notify on change */
1090         if ((GNUNET_YES == cur->addr->active))
1091         {
1092           s->bw_changed (s->bw_changed_cls, cur->addr);
1093         }
1094       }
1095   }
1096 }
1097
1098
1099 /**
1100  * Distribibute bandwidth
1101  *
1102  * @param s the solver handle
1103  * @param n the network, can be NULL for all network
1104  * @param address_except do not notify for this address
1105  */
1106 static void
1107 distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s,
1108                                  struct Network *n)
1109 {
1110   if (GNUNET_YES == s->bulk_lock)
1111   {
1112     s->bulk_requests++;
1113     return;
1114   }
1115
1116   if (NULL != n)
1117   {
1118     LOG (GNUNET_ERROR_TYPE_INFO,
1119         "Redistributing bandwidth in network %s with %u active and %u total addresses\n",
1120         GNUNET_ATS_print_network_type(n->type),
1121         n->active_addresses, n->total_addresses);
1122
1123     if (NULL != s->env->info_cb)
1124       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_START,
1125           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1126
1127     /* Distribute  */
1128     distribute_bandwidth(s, n);
1129
1130     if (NULL != s->env->info_cb)
1131       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_STOP,
1132           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1133     if (NULL != s->env->info_cb)
1134       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
1135           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1136
1137     /* Do propagation */
1138     propagate_bandwidth (s, n);
1139
1140     if (NULL != s->env->info_cb)
1141       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
1142           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1143   }
1144   else
1145   {
1146     int i;
1147     if (NULL != s->env->info_cb)
1148       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_START,
1149           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1150     for (i = 0; i < s->network_count; i++)
1151     {
1152       /* Distribute */
1153       distribute_bandwidth(s, &s->network_entries[i]);
1154     }
1155
1156     if (NULL != s->env->info_cb)
1157       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_STOP,
1158           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1159     if (NULL != s->env->info_cb)
1160       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
1161           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1162     for (i = 0; i < s->network_count; i++)
1163     {
1164       /* Do propagation */
1165       propagate_bandwidth(s, &s->network_entries[i]);
1166     }
1167     if (NULL != s->env->info_cb)
1168       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
1169           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1170   }
1171 }
1172
1173
1174 /**
1175  * FIXME
1176  */
1177 static const struct ATS_Address *
1178 update_active_address (struct GAS_PROPORTIONAL_Handle *s,
1179                        const struct GNUNET_PeerIdentity *peer)
1180 {
1181   struct ATS_Address *best_address;
1182   struct ATS_Address *current_address;
1183   struct AddressSolverInformation *asi;
1184   struct Network *net;
1185
1186   LOG (GNUNET_ERROR_TYPE_INFO,
1187        "Updating active address for peer `%s'\n",
1188        GNUNET_i2s (peer));
1189
1190   /* Find active address */
1191   current_address = get_active_address (s, s->addresses, peer);
1192   /* Find best address */
1193   best_address = get_best_address (s,s->addresses, peer);
1194
1195   if (NULL != current_address)
1196   {
1197     if ((NULL == best_address) || ((NULL != best_address) &&
1198         (GNUNET_NO == address_eq (current_address, best_address))))
1199     {
1200       /* We switch to a new address, mark old address as inactive */
1201       LOG (GNUNET_ERROR_TYPE_INFO,
1202           "Disabling previous %s address %p for peer `%s'\n",
1203           (GNUNET_NO == current_address->active) ? "inactive" : "active",
1204           current_address,
1205           GNUNET_i2s (peer));
1206
1207       asi = current_address->solver_information;
1208       GNUNET_assert (NULL != asi);
1209
1210       net = asi->network;
1211       asi->activated = GNUNET_TIME_UNIT_ZERO_ABS;
1212       current_address->active = GNUNET_NO; /* No active any longer */
1213       current_address->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1214       current_address->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1215
1216       if (GNUNET_SYSERR == addresse_decrement (s, net, GNUNET_NO, GNUNET_YES))
1217         GNUNET_break(0);
1218
1219       /* Update network of previous address */
1220       distribute_bandwidth_in_network (s, net);
1221     }
1222     if (NULL == best_address)
1223     {
1224       /* We previously had an active address, but now we cannot suggest one
1225        * Therefore we have to disconnect the peer */
1226
1227       LOG (GNUNET_ERROR_TYPE_INFO,
1228           "Disconnecting peer `%s' with previous %s address %p\n",
1229           GNUNET_i2s (peer),
1230           (GNUNET_NO == current_address->active) ? "inactive" : "active",
1231           current_address);
1232       s->bw_changed (s->bw_changed_cls, current_address);
1233     }
1234   }
1235
1236   if (NULL == best_address)
1237   {
1238     LOG (GNUNET_ERROR_TYPE_INFO, "Cannot suggest address for peer `%s'\n",
1239         GNUNET_i2s (peer));
1240     return NULL ;
1241   }
1242
1243   LOG (GNUNET_ERROR_TYPE_INFO, "Suggesting %s address %p for peer `%s'\n",
1244       (GNUNET_NO == best_address->active) ? "inactive" : "active", best_address,
1245       GNUNET_i2s (peer));
1246
1247   if ((NULL != current_address) &&
1248       (GNUNET_YES == address_eq (best_address, current_address)))
1249   {
1250     if (current_address->active == GNUNET_NO)
1251       GNUNET_break (0); /* Should never happen */
1252     return best_address; /* Same same */
1253   }
1254
1255   asi = best_address->solver_information;
1256   GNUNET_assert (NULL != asi);
1257   net = asi->network;
1258
1259   /* Mark address as active */
1260   asi->activated = GNUNET_TIME_absolute_get();
1261   best_address->active = GNUNET_YES;
1262   address_increment (s, net, GNUNET_NO, GNUNET_YES);
1263
1264   /* Distribute bandwidth */
1265   distribute_bandwidth_in_network (s, net);
1266   return best_address;
1267 }
1268
1269
1270 /**
1271  * Changes the preferences for a peer in the problem
1272  *
1273  * @param solver the solver handle
1274  * @param peer the peer to change the preference for
1275  * @param kind the kind to change the preference
1276  * @param pref_rel the normalized preference value for this kind over all clients
1277  */
1278 static void
1279 GAS_proportional_address_change_preference (void *solver,
1280                                             const struct GNUNET_PeerIdentity *peer,
1281                                             enum GNUNET_ATS_PreferenceKind kind,
1282                                             double pref_rel)
1283 {
1284   struct GAS_PROPORTIONAL_Handle *s = solver;
1285   struct ATS_Address *best_address;
1286   struct ATS_Address *active_address;
1287   struct AddressSolverInformation *asi;
1288
1289   GNUNET_assert(NULL != s);
1290   GNUNET_assert(NULL != peer);
1291
1292   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, peer))
1293     return; /* Peer is not requested */
1294
1295   /* This peer is requested, find best address */
1296   active_address = get_active_address(s, s->addresses, peer);
1297   best_address = (struct ATS_Address *) update_active_address (s, peer);
1298
1299   if ((NULL != best_address) && ((NULL != active_address) &&
1300       (GNUNET_YES == address_eq (active_address, best_address))))
1301   {
1302     asi = best_address->solver_information;
1303     GNUNET_assert (NULL != asi);
1304
1305     /* We sticked to the same address, therefore redistribute  */
1306     distribute_bandwidth_in_network (s, asi->network);
1307   }
1308 }
1309
1310
1311 /**
1312  * Get application feedback for a peer
1313  *
1314  * @param solver the solver handle
1315  * @param application the application
1316  * @param peer the peer to change the preference for
1317  * @param scope the time interval for this feedback: [now - scope .. now]
1318  * @param kind the kind to change the preference
1319  * @param score the score
1320  */
1321 static void
1322 GAS_proportional_address_preference_feedback (void *solver,
1323                                               void *application,
1324                                               const struct GNUNET_PeerIdentity *peer,
1325                                               const struct GNUNET_TIME_Relative scope,
1326                                               enum GNUNET_ATS_PreferenceKind kind,
1327                                               double score)
1328 {
1329   struct GAS_PROPORTIONAL_Handle *s = solver;
1330
1331   GNUNET_assert(NULL != peer);
1332   GNUNET_assert(NULL != s);
1333 }
1334
1335
1336 /**
1337  * Get the preferred address for a specific peer
1338  *
1339  * @param solver the solver handle
1340  * @param peer the identity of the peer
1341  * @return FIXME
1342  */
1343 static const struct ATS_Address *
1344 GAS_proportional_get_preferred_address (void *solver,
1345                                         const struct GNUNET_PeerIdentity *peer)
1346 {
1347   struct GAS_PROPORTIONAL_Handle *s = solver;
1348   const struct ATS_Address *best_address;
1349
1350
1351   GNUNET_assert(s != NULL);
1352   GNUNET_assert(peer != NULL);
1353
1354   /* Add to list of pending requests */
1355   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, peer))
1356   {
1357     GNUNET_assert(
1358         GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (s->requests, peer, NULL,
1359             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1360     LOG (GNUNET_ERROR_TYPE_INFO, "Start suggesting addresses for peer `%s'\n",
1361           GNUNET_i2s (peer));
1362   }
1363
1364   best_address = update_active_address (s, peer);
1365   if (s->bulk_lock > 0)
1366     return NULL; /* Do not suggest since bulk lock is pending */
1367
1368   return best_address;
1369 }
1370
1371
1372 /**
1373  * Stop notifying about address and bandwidth changes for this peer
1374  *
1375  * @param solver the solver handle
1376  * @param peer the peer
1377  */
1378 static void
1379 GAS_proportional_stop_get_preferred_address (void *solver,
1380                                              const struct GNUNET_PeerIdentity *peer)
1381 {
1382   struct GAS_PROPORTIONAL_Handle *s = solver;
1383   struct ATS_Address *cur;
1384   struct AddressSolverInformation *asi;
1385   struct Network *cur_net;
1386
1387   if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (s->requests, peer))
1388     GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (s->requests,
1389         peer, NULL));
1390
1391   cur = get_active_address (s, s->addresses, peer);
1392   if (NULL != cur)
1393   {
1394     LOG(GNUNET_ERROR_TYPE_INFO,
1395         "Disabling %s address %p for peer `%s'\n",
1396         (GNUNET_NO == cur->active) ? "inactive" : "active", cur,
1397         GNUNET_i2s (&cur->peer));
1398
1399     /* Disabling current address */
1400     asi = cur->solver_information;
1401     cur_net = asi->network ;
1402     asi->activated = GNUNET_TIME_UNIT_ZERO_ABS;
1403     cur->active = GNUNET_NO; /* No active any longer */
1404     cur->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1405     cur->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1406
1407     if (GNUNET_SYSERR == addresse_decrement (s, cur_net, GNUNET_NO, GNUNET_YES))
1408       GNUNET_break(0);
1409
1410     distribute_bandwidth_in_network (s, cur_net );
1411   }
1412   return;
1413 }
1414
1415
1416 /**
1417  * Remove an address from the solver
1418  *
1419  * @param solver the solver handle
1420  * @param address the address to remove
1421  * @param session_only delete only session not whole address
1422  */
1423 static void
1424 GAS_proportional_address_delete (void *solver,
1425                                  struct ATS_Address *address,
1426                                  int session_only)
1427 {
1428   struct GAS_PROPORTIONAL_Handle *s = solver;
1429   struct Network *net;
1430   struct AddressWrapper *aw;
1431   struct AddressSolverInformation *asi;
1432
1433   /* Remove an adress completely, we have to:
1434    * - Remove from specific network
1435    * - Decrease number of total addresses
1436    * - If active:
1437    *   - decrease number of active addreses
1438    *   - update quotas
1439    */
1440   asi = address->solver_information;
1441
1442   if (NULL == asi)
1443   {
1444     GNUNET_break (0);
1445     return;
1446   }
1447   net = asi->network;
1448
1449   if (GNUNET_NO == session_only)
1450   {
1451     LOG(GNUNET_ERROR_TYPE_INFO,
1452         "Deleting %s address %p for peer `%s' from network `%s' (total: %u/ active: %u)\n",
1453         (GNUNET_NO == address->active) ? "inactive" : "active", address,
1454         GNUNET_i2s (&address->peer), net->desc, net->total_addresses,
1455         net->active_addresses);
1456
1457     /* Remove address */
1458     addresse_decrement (s, net, GNUNET_YES, GNUNET_NO);
1459     for (aw = net->head; NULL != aw; aw = aw->next)
1460     {
1461       if (aw->addr == address)
1462         break;
1463     }
1464     if (NULL == aw)
1465     {
1466       GNUNET_break(0);
1467       return;
1468     }
1469     GNUNET_CONTAINER_DLL_remove(net->head, net->tail, aw);
1470     GNUNET_free(aw);
1471   }
1472   else
1473   {
1474     /* Remove session only: remove if active and update */
1475     LOG(GNUNET_ERROR_TYPE_INFO,
1476         "Deleting %s session %p for peer `%s' from network `%s' (total: %u/ active: %u)\n",
1477         (GNUNET_NO == address->active) ? "inactive" : "active", address,
1478         GNUNET_i2s (&address->peer), net->desc, net->total_addresses,
1479         net->active_addresses);
1480   }
1481
1482   if (GNUNET_YES == address->active)
1483   {
1484     /* Address was active, remove from network and update quotas*/
1485     address->active = GNUNET_NO;
1486     address->assigned_bw_in = BANDWIDTH_ZERO;
1487     address->assigned_bw_out = BANDWIDTH_ZERO;
1488     asi->calculated_quota_in_NBO = htonl (0);
1489     asi->calculated_quota_out_NBO = htonl (0);
1490
1491     if (GNUNET_SYSERR == addresse_decrement (s, net, GNUNET_NO, GNUNET_YES))
1492       GNUNET_break(0);
1493     distribute_bandwidth_in_network (s, net);
1494
1495     if (NULL == update_active_address (s, &address->peer))
1496     {
1497       /* No alternative address found, disconnect peer */
1498       LOG (GNUNET_ERROR_TYPE_INFO,
1499           "Disconnecting peer `%s' after deleting previous %s address %p\n",
1500           GNUNET_i2s (&address->peer),
1501           (GNUNET_NO == address->active) ? "inactive" : "active",
1502               address);
1503       s->bw_changed (s->bw_changed_cls, address);
1504     }
1505   }
1506   if (GNUNET_NO == session_only)
1507   {
1508     GNUNET_free_non_null (address->solver_information);
1509     address->solver_information = NULL;
1510   }
1511
1512   LOG(GNUNET_ERROR_TYPE_INFO,
1513       "After deleting address now total %u and active %u addresses in network `%s'\n",
1514       net->total_addresses, net->active_addresses, net->desc);
1515
1516 }
1517
1518
1519 /**
1520  * Start a bulk operation
1521  *
1522  * @param solver the solver
1523  */
1524 static void
1525 GAS_proportional_bulk_start (void *solver)
1526 {
1527   struct GAS_PROPORTIONAL_Handle *s = solver;
1528
1529   LOG (GNUNET_ERROR_TYPE_DEBUG,
1530        "Locking solver for bulk operation ...\n");
1531   GNUNET_assert(NULL != solver);
1532   s->bulk_lock++;
1533 }
1534
1535
1536 /**
1537  * Bulk operation done
1538  */
1539 static void
1540 GAS_proportional_bulk_stop (void *solver)
1541 {
1542   struct GAS_PROPORTIONAL_Handle *s = solver;
1543
1544   LOG (GNUNET_ERROR_TYPE_DEBUG,
1545        "Unlocking solver from bulk operation ...\n");
1546   GNUNET_assert(NULL != solver);
1547
1548   if (s->bulk_lock < 1)
1549   {
1550     GNUNET_break(0);
1551     return;
1552   }
1553   s->bulk_lock--;
1554   if ((0 == s->bulk_lock) && (0 < s->bulk_requests))
1555   {
1556     LOG(GNUNET_ERROR_TYPE_INFO, "No lock pending, recalculating\n");
1557     distribute_bandwidth_in_network (s, NULL);
1558     s->bulk_requests = 0;
1559   }
1560 }
1561
1562
1563 /**
1564  * Add a new single address to a network
1565  *
1566  * @param solver the solver Handle
1567  * @param address the address to add
1568  * @param network network type of this address
1569  */
1570 static void
1571 GAS_proportional_address_add (void *solver,
1572                               struct ATS_Address *address,
1573                               uint32_t network);
1574
1575
1576 /**
1577  * Transport properties for this address have changed
1578  *
1579  * @param solver solver handle
1580  * @param address the address
1581  * @param type the ATSI type in HBO
1582  * @param abs_value the absolute value of the property
1583  * @param rel_value the normalized value
1584  */
1585 static void
1586 GAS_proportional_address_property_changed (void *solver,
1587                                            struct ATS_Address *address,
1588                                            uint32_t type,
1589                                            uint32_t abs_value,
1590                                            double rel_value)
1591 {
1592   struct GAS_PROPORTIONAL_Handle *s = solver;
1593   struct Network *n;
1594   struct AddressSolverInformation *asi;
1595   struct ATS_Address *best_address;
1596   struct ATS_Address *active_address;
1597
1598   GNUNET_assert(NULL != s);
1599   GNUNET_assert(NULL != address);
1600   asi = address->solver_information;
1601   if (NULL == asi)
1602   {
1603     GNUNET_break(0);
1604     return;
1605   }
1606
1607   n = asi->network;
1608   if (NULL == n)
1609   {
1610     GNUNET_break(0);
1611     return;
1612   }
1613
1614   LOG(GNUNET_ERROR_TYPE_INFO,
1615       "Property `%s' for peer `%s' address %p changed to %.2f \n",
1616       GNUNET_ATS_print_property_type (type), GNUNET_i2s (&address->peer),
1617       address, rel_value);
1618
1619   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1620     return; /* Peer is not requested */
1621
1622   /* This peer is requested, find active and best address */
1623   active_address = get_active_address(s, s->addresses, &address->peer);
1624   best_address = (struct ATS_Address *) update_active_address (s, &address->peer);
1625
1626   if ((NULL != best_address) && ((NULL != active_address) &&
1627       (GNUNET_YES == address_eq (active_address, best_address))))
1628   {
1629     asi = best_address->solver_information;
1630     GNUNET_assert (NULL != asi);
1631
1632     /* We sticked to the same address, therefore redistribute  */
1633     distribute_bandwidth_in_network (s, asi->network);
1634   }
1635 }
1636
1637 /**
1638  * Transport session for this address has changed
1639  *
1640  * NOTE: values in addresses are already updated
1641  *
1642  * @param solver solver handle
1643  * @param address the address
1644  * @param cur_session the current session
1645  * @param new_session the new session
1646  */
1647 static void
1648 GAS_proportional_address_session_changed (void *solver,
1649                                           struct ATS_Address *address,
1650                                           uint32_t cur_session,
1651                                           uint32_t new_session)
1652 {
1653   struct GAS_PROPORTIONAL_Handle *s = solver;
1654   struct ATS_Address *best_address;
1655   struct ATS_Address *active_address;
1656   struct AddressSolverInformation *asi;
1657
1658   if (cur_session != new_session)
1659   {
1660     LOG (GNUNET_ERROR_TYPE_DEBUG,
1661          "Session changed from %u to %u\n",
1662          cur_session,
1663          new_session);
1664   }
1665
1666   if (NULL == address->solver_information)
1667   {
1668     GNUNET_break (0);
1669     return;
1670   }
1671
1672   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1673     return; /* Peer is not requested */
1674
1675   /* This peer is requested, find active and best address */
1676   active_address = get_active_address(s, s->addresses, &address->peer);
1677   best_address = (struct ATS_Address *) update_active_address (s, &address->peer);
1678
1679   if ((NULL != best_address) && ((NULL != active_address) &&
1680       (GNUNET_YES == address_eq (active_address, best_address))))
1681   {
1682     asi = best_address->solver_information;
1683     GNUNET_assert (NULL != asi);
1684
1685     /* We sticked to the same address, therefore redistribute  */
1686     distribute_bandwidth_in_network (s, asi->network);
1687   }
1688 }
1689
1690
1691 /**
1692  * Usage for this address has changed
1693  *
1694  * NOTE: values in addresses are already updated
1695  *
1696  * @param solver solver handle
1697  * @param address the address
1698  * @param in_use usage state
1699  */
1700 static void
1701 GAS_proportional_address_inuse_changed (void *solver,
1702                                         struct ATS_Address *address,
1703                                         int in_use)
1704 {
1705   struct GAS_PROPORTIONAL_Handle *s = solver;
1706   struct Network *n;
1707   struct AddressSolverInformation *asi;
1708   struct ATS_Address *best_address;
1709   struct ATS_Address *active_address;
1710
1711   GNUNET_assert(NULL != s);
1712   GNUNET_assert(NULL != address);
1713   asi = address->solver_information;
1714   if (NULL == asi)
1715   {
1716     GNUNET_break(0);
1717     return;
1718   }
1719
1720   n = asi->network;
1721   if (NULL == n)
1722   {
1723     GNUNET_break(0);
1724     return;
1725   }
1726
1727   LOG(GNUNET_ERROR_TYPE_INFO,
1728       "Usage of peer `%s' address %p changed to %s \n",
1729       GNUNET_i2s (&address->peer), address,
1730       (GNUNET_YES == in_use) ? "YES" : "NO");
1731
1732   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1733     return; /* Peer is not requested */
1734
1735   /* This peer is requested, find active and best address */
1736   active_address = get_active_address(s, s->addresses, &address->peer);
1737   best_address = (struct ATS_Address *) update_active_address (s, &address->peer);
1738
1739   if ((NULL != best_address) && ((NULL != active_address) &&
1740       (GNUNET_YES == address_eq (active_address, best_address))))
1741   {
1742     asi = best_address->solver_information;
1743     GNUNET_assert (NULL != asi);
1744
1745     /* We sticked to the same address, therefore redistribute  */
1746     distribute_bandwidth_in_network (s, asi->network);
1747   }
1748 }
1749
1750 /**
1751  * Network scope for this address has changed
1752  *
1753  * NOTE: values in addresses are already updated
1754  *
1755  * @param solver solver handle
1756  * @param address the address
1757  * @param current_network the current network
1758  * @param new_network the new network
1759  */
1760 static void
1761 GAS_proportional_address_change_network (void *solver,
1762                                          struct ATS_Address *address,
1763                                          uint32_t current_network,
1764                                          uint32_t new_network)
1765 {
1766   struct GAS_PROPORTIONAL_Handle *s = solver;
1767   struct AddressSolverInformation *asi;
1768   int save_active = GNUNET_NO;
1769
1770   if (current_network == new_network)
1771   {
1772     GNUNET_break(0);
1773     return;
1774   }
1775
1776   asi = address->solver_information;
1777   if (NULL == asi)
1778   {
1779     GNUNET_break(0);
1780     return;
1781   }
1782
1783   /* Network changed */
1784   LOG(GNUNET_ERROR_TYPE_DEBUG,
1785       "Network type changed, moving %s address from `%s' to `%s'\n",
1786       (GNUNET_YES == address->active) ? "active" : "inactive",
1787       GNUNET_ATS_print_network_type (current_network),
1788       GNUNET_ATS_print_network_type (new_network));
1789
1790
1791   /* Start bulk to prevent disconnect */
1792   GAS_proportional_bulk_start(s);
1793
1794   save_active = address->active;
1795
1796   /* Disable and assign no bandwidth */
1797   address->active = GNUNET_NO;
1798   address->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1799   address->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1800
1801   /* Remove from old network */
1802   GAS_proportional_address_delete (solver, address, GNUNET_NO);
1803
1804   /* Set new network type */
1805   if (NULL == get_network (solver, new_network))
1806   {
1807     /* Address changed to invalid network... */
1808     LOG(GNUNET_ERROR_TYPE_ERROR,
1809         _("Invalid network type `%u' `%s': Disconnect!\n"), new_network,
1810         GNUNET_ATS_print_network_type (new_network));
1811     s->bw_changed (s->bw_changed_cls, address);
1812   }
1813   else
1814   {
1815     /* Add to new network and update*/
1816     GAS_proportional_address_add (solver, address, new_network);
1817   }
1818   GAS_proportional_bulk_stop (s);
1819
1820   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1821     return; /* Peer is not requested */
1822
1823   /* Find new address to suggest */
1824   if (GNUNET_YES == save_active)
1825   {
1826     /* No address available, therefore disconnect */
1827     if (NULL == update_active_address (s, &address->peer))
1828       s->bw_changed (s->bw_changed_cls, address);
1829   }
1830
1831 }
1832
1833 /**
1834  * Add a new single address to a network
1835  *
1836  * @param solver the solver Handle
1837  * @param address the address to add
1838  * @param network network type of this address
1839  */
1840 static void
1841 GAS_proportional_address_add (void *solver,
1842                               struct ATS_Address *address,
1843                               uint32_t network)
1844 {
1845   struct GAS_PROPORTIONAL_Handle *s = solver;
1846   struct Network *net = NULL;
1847   struct AddressWrapper *aw = NULL;
1848   struct AddressSolverInformation *asi;
1849
1850   GNUNET_assert(NULL != s);
1851   net = get_network (s, network);
1852   if (NULL == net)
1853   {
1854     GNUNET_break(0);
1855
1856     LOG(GNUNET_ERROR_TYPE_ERROR,
1857         "Unknown network %u `%s' for new address %p for peer `%s'\n",
1858         network, GNUNET_ATS_print_network_type(network),
1859         address, GNUNET_i2s(&address->peer));
1860
1861     return;
1862   }
1863
1864   aw = GNUNET_new (struct AddressWrapper);
1865   aw->addr = address;
1866   GNUNET_CONTAINER_DLL_insert(net->head, net->tail, aw);
1867   address_increment (s, net, GNUNET_YES, GNUNET_NO);
1868
1869   asi = GNUNET_new (struct AddressSolverInformation);
1870   asi->network = net;
1871   asi->calculated_quota_in_NBO = htonl (0);
1872   asi->calculated_quota_out_NBO = htonl (0);
1873   aw->addr->solver_information = asi;
1874
1875   LOG(GNUNET_ERROR_TYPE_INFO,
1876       "Adding new address %p for peer `%s', now total %u and active %u addresses in network `%s'\n",
1877       address, GNUNET_i2s(&address->peer), net->total_addresses, net->active_addresses, net->desc);
1878
1879   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1880     return; /* Peer is not requested */
1881
1882   /* This peer is requested, find best address */
1883   update_active_address (s, &address->peer);
1884 }
1885
1886
1887
1888 /**
1889  * Function invoked when the plugin is loaded.
1890  *
1891  * @param cls[in,out] the `struct GNUNET_ATS_PluginEnvironment *` to use;
1892  *            modified to return the API functions (ugh).
1893  * @return the `struct GAS_PROPORTIONAL_Handle` to pass as a closure
1894  */
1895 void *
1896 libgnunet_plugin_ats_proportional_init (void *cls)
1897 {
1898   struct GNUNET_ATS_PluginEnvironment *env = cls;
1899   struct GAS_PROPORTIONAL_Handle *s;
1900   struct Network * cur;
1901   char * net_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
1902   float f_tmp;
1903   int c;
1904
1905   GNUNET_assert (NULL != env);
1906   GNUNET_assert (NULL != env->cfg);
1907   GNUNET_assert (NULL != env->bandwidth_changed_cb);
1908   GNUNET_assert (NULL != env->get_preferences);
1909   GNUNET_assert (NULL != env->get_property);
1910
1911   s = GNUNET_new (struct GAS_PROPORTIONAL_Handle);
1912   s->env = env;
1913   env->sf.s_add = &GAS_proportional_address_add;
1914   env->sf.s_address_update_property = &GAS_proportional_address_property_changed;
1915   env->sf.s_address_update_session = &GAS_proportional_address_session_changed;
1916   env->sf.s_address_update_inuse = &GAS_proportional_address_inuse_changed;
1917   env->sf.s_address_update_network = &GAS_proportional_address_change_network;
1918   env->sf.s_get = &GAS_proportional_get_preferred_address;
1919   env->sf.s_get_stop = &GAS_proportional_stop_get_preferred_address;
1920   env->sf.s_pref = &GAS_proportional_address_change_preference;
1921   env->sf.s_feedback = &GAS_proportional_address_preference_feedback;
1922   env->sf.s_del = &GAS_proportional_address_delete;
1923   env->sf.s_bulk_start = &GAS_proportional_bulk_start;
1924   env->sf.s_bulk_stop = &GAS_proportional_bulk_stop;
1925
1926   s->stats = (struct GNUNET_STATISTICS_Handle *) env->stats;
1927   s->bw_changed = env->bandwidth_changed_cb;
1928   s->bw_changed_cls = env->bw_changed_cb_cls;
1929   s->get_preferences = env->get_preferences;
1930   s->get_preferences_cls = env->get_preference_cls;
1931   s->get_properties = env->get_property;
1932   s->get_properties_cls = env->get_property_cls;
1933   s->network_count = env->network_count;
1934   s->network_entries = GNUNET_malloc (env->network_count * sizeof (struct Network));
1935
1936   /* Init */
1937   s->active_addresses = 0;
1938   s->total_addresses = 0;
1939   s->bulk_lock = GNUNET_NO;
1940   s->addresses = env->addresses;
1941   s->requests = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
1942
1943   s->stability_factor = PROP_STABILITY_FACTOR;
1944   if (GNUNET_SYSERR !=
1945       GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
1946                                             "PROP_STABILITY_FACTOR", &f_tmp))
1947   {
1948     if ((f_tmp < 1.0) || (f_tmp > 2.0))
1949     {
1950       LOG (GNUNET_ERROR_TYPE_ERROR,
1951            _("Invalid %s configuration %f \n"),
1952            "PROP_STABILITY_FACTOR",
1953            f_tmp);
1954     }
1955     else
1956     {
1957       s->stability_factor = f_tmp;
1958       LOG (GNUNET_ERROR_TYPE_INFO,
1959            "Using %s of %.3f\n",
1960            "PROP_STABILITY_FACTOR", f_tmp);
1961     }
1962   }
1963
1964   s->prop_factor = PROPORTIONALITY_FACTOR;
1965   if (GNUNET_SYSERR !=
1966       GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
1967                                             "PROP_STABILITY_FACTOR", &f_tmp))
1968   {
1969     if (f_tmp < 1.0)
1970     {
1971       LOG (GNUNET_ERROR_TYPE_ERROR,
1972            _("Invalid %s configuration %f \n"),
1973            "PROP_PROPORTIONALITY_FACTOR", f_tmp);
1974     }
1975     else
1976     {
1977       s->prop_factor = f_tmp;
1978       LOG (GNUNET_ERROR_TYPE_INFO,
1979            "Using %s of %.3f\n",
1980            "PROP_PROPORTIONALITY_FACTOR", f_tmp);
1981     }
1982   }
1983
1984   for (c = 0; c < env->network_count; c++)
1985   {
1986     cur = &s->network_entries[c];
1987     cur->total_addresses = 0;
1988     cur->active_addresses = 0;
1989     cur->type = env->networks[c];
1990     cur->total_quota_in = env->in_quota[c];
1991     cur->total_quota_out = env->out_quota[c];
1992     cur->desc = net_str[c];
1993     GNUNET_asprintf (&cur->stat_total,
1994         "# ATS addresses %s total", cur->desc);
1995     GNUNET_asprintf (&cur->stat_active,
1996         "# ATS active addresses %s total", cur->desc);
1997     LOG (GNUNET_ERROR_TYPE_INFO,
1998          "Added network %u `%s' (%llu/%llu)\n",
1999         c, cur->desc, cur->total_quota_in, cur->total_quota_out);
2000   }
2001   return s;
2002 }
2003
2004
2005 /* end of plugin_ats_proportional.c */