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    * Linked list of addresses in this network: head
 356    */
 357   struct AddressWrapper *head;
 358
 359   /**
 360    * Linked list of addresses in this network: tail
 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  * Context for finding the best address* Linked list of addresses in this network: head
 665  */
 666 struct FindBestAddressCtx
 667 {
 668   /**
 669    * The solver handle
 670    */
 671   struct GAS_PROPORTIONAL_Handle *s;
 672
 673   /**
 674    * The currently best address
 675    */
 676   struct ATS_Address *best;
 677 };
 678
 679
 680 /**
 681  * Find index of a ATS property type in the array.
 682  */
 683 static int
 684 find_property_index (uint32_t type)
 685 {
 686   int existing_types[] = GNUNET_ATS_QualityProperties;
 687   int c;
 688
 689   for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
 690     if (existing_types[c] == type)
 691       return c;
 692   return GNUNET_SYSERR;
 693 }
 694
 695
 696 /**
 697  * Find a "good" address to use for a peer by iterating over the addresses for this peer.
 698  * If we already have an existing address, we stick to it.
 699  * Otherwise, we pick by lowest distance and then by lowest latency.
 700  *
 701  * @param cls the `struct FindBestAddressCtx *' where we store the result
 702  * @param key unused
 703  * @param value another `struct ATS_Address*` to consider using
 704  * @return #GNUNET_OK (continue to iterate)
 705  */
 706 static int
 707 find_best_address_it (void *cls,
 708                       const struct GNUNET_PeerIdentity *key,
 709                       void *value)
 710 {
 711   struct FindBestAddressCtx *ctx = cls;
 712   struct ATS_Address *current = value;
 713   struct ATS_Address *current_best = current;
 714   struct GNUNET_TIME_Absolute now;
 715   struct AddressSolverInformation *asi;
 716   struct GNUNET_TIME_Relative active_time;
 717   struct GNUNET_TIME_Relative min_active_time;
 718   const double *norm_prop_cur;
 719   const double *norm_prop_best;
 720   double best_delay;
 721   double best_distance;
 722   double cur_delay;
 723   double cur_distance;
 724   int index;
 725
 726   current_best = NULL;
 727   asi = current->solver_information;
 728   now = GNUNET_TIME_absolute_get ();
 729
 730   if ((current->active == GNUNET_NO)
 731       && (current->blocked_until.abs_value_us
 732           == GNUNET_TIME_absolute_max (now, current->blocked_until).abs_value_us))
 733   {
 734     /* This address is blocked for suggestion */
 735     LOG (GNUNET_ERROR_TYPE_DEBUG,
 736          "Address %p blocked for suggestion for %s \n",
 737          current,
 738          GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_difference (now, current->blocked_until),
 739                                                  GNUNET_YES));
 740     return GNUNET_OK;
 741   }
 742   if (NULL == asi)
 743   {
 744     GNUNET_break (0);
 745     return GNUNET_OK;
 746   }
 747
 748   if (GNUNET_NO == is_bandwidth_available_in_network (asi->network))
 749   {
 750     return GNUNET_OK; /* There's no bandwidth available in this network */
 751   }
 752
 753   if (NULL != ctx->best)
 754   {
 755     /* Compare current addresses with denominated 'best' address */
 756     current_best = ctx->best;
 757   }
 758   else
 759   {
 760     /* We do not have a 'best' address so take this address */
 761     LOG (GNUNET_ERROR_TYPE_DEBUG,
 762          "Setting initial address %p\n",
 763          current);
 764     current_best = current;
 765     goto end;
 766   }
 767
 768   if (GNUNET_YES == current->active)
 769   {
 770     GNUNET_assert (asi->activated.abs_value_us != GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us);
 771     active_time = GNUNET_TIME_absolute_get_duration (asi->activated);
 772     min_active_time.rel_value_us =  ((double) GNUNET_TIME_UNIT_SECONDS.rel_value_us) *
 773         PROP_STABILITY_FACTOR;
 774     if (active_time.rel_value_us <= min_active_time.rel_value_us)
 775     {
 776       /* Keep active address for stability reasons */
 777       ctx->best = current;
 778       return GNUNET_NO;
 779     }
 780   }
 781
 782   /* Now compare ATS information */
 783   norm_prop_cur = ctx->s->get_properties (ctx->s->get_properties_cls,
 784       (const struct ATS_Address *) current);
 785   index = find_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE);
 786   cur_distance = norm_prop_cur[index];
 787   index = find_property_index (GNUNET_ATS_QUALITY_NET_DELAY);
 788   cur_delay = norm_prop_cur[index];
 789
 790   norm_prop_best = ctx->s->get_properties (ctx->s->get_properties_cls,
 791       (const struct ATS_Address *) ctx->best);
 792   index = find_property_index (GNUNET_ATS_QUALITY_NET_DISTANCE);
 793   best_distance = norm_prop_best[index];
 794   index = find_property_index (GNUNET_ATS_QUALITY_NET_DELAY);
 795   best_delay = norm_prop_best[index];
 796
 797   /* user shorter distance */
 798   if (cur_distance < best_distance)
 799   {
 800
 801     if (GNUNET_NO == ctx->best->active)
 802     {
 803       current_best = current; /* Use current */
 804     }
 805     else if ((best_distance / cur_distance) > ctx->s->stability_factor)
 806     {
 807       /* Best and active address performs worse  */
 808       current_best = current;
 809     }
 810   }
 811   else
 812   {
 813     /* Use current best */
 814     current_best = ctx->best;
 815   }
 816
 817   /* User connection with less delay */
 818   if (cur_delay < best_delay)
 819   {
 820
 821     if (GNUNET_NO == ctx->best->active)
 822     {
 823       current_best = current; /* Use current */
 824     }
 825     else if ((best_delay / cur_delay) > ctx->s->stability_factor)
 826     {
 827       /* Best and active address performs worse  */
 828       current_best = current;
 829     }
 830   }
 831   else
 832   {
 833     /* Use current best */
 834     current_best = ctx->best;
 835   }
 836
 837 end:
 838   ctx->best = current_best;
 839   return GNUNET_OK;
 840 }
 841
 842
 843 /**
 844  * Find the currently best address for a peer from the set of addresses available
 845  * or return NULL of no address is available
 846  *
 847  * @param s the proportional handle
 848  * @param addresses the address hashmap
 849  * @param id the peer id
 850  * @return the address or NULL
 851  */
 852 struct ATS_Address *
 853 get_best_address (struct GAS_PROPORTIONAL_Handle *s,
 854                   struct GNUNET_CONTAINER_MultiPeerMap *addresses,
 855                   const struct GNUNET_PeerIdentity *id)
 856 {
 857   struct FindBestAddressCtx fba_ctx;
 858
 859   fba_ctx.best = NULL;
 860   fba_ctx.s = s;
 861   GNUNET_CONTAINER_multipeermap_get_multiple (addresses, id,
 862                                               &find_best_address_it, &fba_ctx);
 863
 864   return fba_ctx.best;
 865 }
 866
 867
 868 /**
 869  * Hashmap Iterator to find current active address for peer
 870  *
 871  * @param cls last active address
 872  * @param key peer's key
 873  * @param value address to check
 874  * @return #GNUNET_NO on double active address else #GNUNET_YES;
 875  */
 876 static int
 877 get_active_address_it (void *cls,
 878                        const struct GNUNET_PeerIdentity *key,
 879                        void *value)
 880 {
 881   struct ATS_Address **dest = cls;
 882   struct ATS_Address *aa = (struct ATS_Address *) value;
 883
 884   LOG (GNUNET_ERROR_TYPE_INFO,
 885          "Checking address %p\n", aa);
 886
 887   if (GNUNET_YES == aa->active)
 888   {
 889   LOG (GNUNET_ERROR_TYPE_INFO,
 890          "Address %p is active\n", aa);
 891     if (NULL != (*dest))
 892     {
 893       /* should never happen */
 894       LOG (GNUNET_ERROR_TYPE_ERROR,
 895            "Multiple active addresses for peer `%s'\n",
 896            GNUNET_i2s (&aa->peer));
 897       GNUNET_break(0);
 898       return GNUNET_NO;
 899     }
 900     (*dest) = aa;
 901
 902   }
 903   return GNUNET_OK;
 904 }
 905
 906
 907 /**
 908  * Find current active address for peer
 909  *
 910  * @param solver the solver handle
 911  * @param addresses the address set
 912  * @param peer the peer
 913  * @return active address or NULL
 914  */
 915 static struct ATS_Address *
 916 get_active_address (void *solver,
 917                     const struct GNUNET_CONTAINER_MultiPeerMap * addresses,
 918                     const struct GNUNET_PeerIdentity *peer)
 919 {
 920   static struct ATS_Address * dest = NULL;
 921
 922   dest = NULL;
 923   GNUNET_CONTAINER_multipeermap_get_multiple (addresses, peer,
 924                                               &get_active_address_it, &dest);
 925   return dest;
 926 }
 927
 928
 929 /**
 930  * Lookup network struct by type
 931  *
 932  * @param s the solver handle
 933  * @param type the network type
 934  * @return the network struct
 935  */
 936 static struct Network *
 937 get_network (struct GAS_PROPORTIONAL_Handle *s, uint32_t type)
 938 {
 939   int c;
 940   for (c = 0; c < s->network_count; c++)
 941   {
 942     if (s->network_entries[c].type == type)
 943       return &s->network_entries[c];
 944   }
 945   return NULL ;
 946 }
 947
 948
 949 /**
 950  * Increase address count in network
 951  *
 952  * @param s the solver handle
 953  * @param net the network type
 954  * @param total increase total addresses
 955  * @param active increase active addresses
 956  */
 957 static void
 958 address_increment (struct GAS_PROPORTIONAL_Handle *s,
 959                     struct Network *net,
 960                     int total,
 961                     int active)
 962 {
 963   if (GNUNET_YES == total)
 964   {
 965     s->total_addresses++;
 966     net->total_addresses++;
 967     GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", 1, GNUNET_NO);
 968     GNUNET_STATISTICS_update (s->stats, net->stat_total, 1, GNUNET_NO);
 969   }
 970   if (GNUNET_YES == active)
 971   {
 972     net->active_addresses++;
 973     s->active_addresses++;
 974     GNUNET_STATISTICS_update (s->stats, "# ATS active addresses total", 1,
 975         GNUNET_NO);
 976     GNUNET_STATISTICS_update (s->stats, net->stat_active, 1, GNUNET_NO);
 977   }
 978
 979 }
 980
 981
 982 /**
 983  * Decrease address count in network
 984  *
 985  * @param s the solver handle
 986  * @param net the network type
 987  * @param total decrease total addresses
 988  * @param active decrease active addresses
 989  */
 990 static int
 991 addresse_decrement (struct GAS_PROPORTIONAL_Handle *s,
 992                     struct Network *net,
 993                     int total,
 994                     int active)
 995 {
 996   int res = GNUNET_OK;
 997
 998   if (GNUNET_YES == total)
 999   {
1000     if (s->total_addresses < 1)
1001     {
1002       GNUNET_break(0);
1003       res = GNUNET_SYSERR;
1004     }
1005     else
1006     {
1007       s->total_addresses--;
1008       GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", -1,
1009           GNUNET_NO);
1010     }
1011     if (net->total_addresses < 1)
1012     {
1013       GNUNET_break(0);
1014       res = GNUNET_SYSERR;
1015     }
1016     else
1017     {
1018       net->total_addresses--;
1019       GNUNET_STATISTICS_update (s->stats, net->stat_total, -1, GNUNET_NO);
1020     }
1021   }
1022
1023   if (GNUNET_YES == active)
1024   {
1025     if (net->active_addresses < 1)
1026     {
1027       GNUNET_break(0);
1028       res = GNUNET_SYSERR;
1029     }
1030     else
1031     {
1032       net->active_addresses--;
1033       GNUNET_STATISTICS_update (s->stats, net->stat_active, -1, GNUNET_NO);
1034     }
1035     if (s->active_addresses < 1)
1036     {
1037       GNUNET_break(0);
1038       res = GNUNET_SYSERR;
1039     }
1040     else
1041     {
1042       s->active_addresses--;
1043       GNUNET_STATISTICS_update (s->stats, "# ATS addresses total", -1,
1044           GNUNET_NO);
1045     }
1046   }
1047   return res;
1048 }
1049
1050
1051 /**
1052  * Compares addresses
1053  *
1054  * @param a address a
1055  * @param b address b
1056  * @return GNUNET_YES if equal, GNUNET_NO else
1057  */
1058 static int
1059 address_eq (struct ATS_Address *a, struct ATS_Address *b)
1060 {
1061   GNUNET_assert (NULL != a);
1062   GNUNET_assert (NULL != b);
1063   if (0 != strcmp(a->plugin, b->plugin))
1064     return GNUNET_NO;
1065   if (a->addr_len != b->addr_len)
1066     return GNUNET_NO;
1067   if (0 != memcmp (a->addr, b->addr, b->addr_len))
1068     return GNUNET_NO;
1069   if (a->session_id != b->session_id)
1070     return GNUNET_NO;
1071   return GNUNET_YES;
1072 }
1073
1074
1075 /**
1076  * Notify bandwidth changes to addresses
1077  *
1078  * @param s solver handle
1079  * @param net the network to propagate changes in
1080  */
1081 static void
1082 propagate_bandwidth (struct GAS_PROPORTIONAL_Handle *s,
1083                      struct Network *net)
1084 {
1085   struct AddressWrapper *cur;
1086   struct AddressSolverInformation *asi;
1087   for (cur = net->head; NULL != cur; cur = cur->next)
1088   {
1089       asi = cur->addr->solver_information;
1090       if ( (cur->addr->assigned_bw_in.value__ != asi->calculated_quota_in_NBO) ||
1091            (cur->addr->assigned_bw_out.value__ != asi->calculated_quota_out_NBO) )
1092       {
1093         cur->addr->assigned_bw_in.value__ = asi->calculated_quota_in_NBO;
1094         cur->addr->assigned_bw_out.value__ = asi->calculated_quota_out_NBO;
1095
1096         /* Reset for next iteration */
1097         asi->calculated_quota_in_NBO = htonl (0);
1098         asi->calculated_quota_out_NBO = htonl (0);
1099
1100         LOG (GNUNET_ERROR_TYPE_DEBUG,
1101             "Bandwidth for %s address %p for peer `%s' changed to %u/%u\n",
1102             (GNUNET_NO == cur->addr->active) ? "inactive" : "active",
1103             cur->addr,
1104             GNUNET_i2s (&cur->addr->peer),
1105             ntohl (cur->addr->assigned_bw_in.value__),
1106             ntohl (cur->addr->assigned_bw_out.value__ ));
1107
1108         /* Notify on change */
1109         if ((GNUNET_YES == cur->addr->active))
1110         {
1111           s->bw_changed (s->bw_changed_cls, cur->addr);
1112         }
1113       }
1114   }
1115 }
1116
1117
1118 /**
1119  * Distribibute bandwidth
1120  *
1121  * @param s the solver handle
1122  * @param n the network, can be NULL for all network
1123  * @param address_except do not notify for this address
1124  */
1125 static void
1126 distribute_bandwidth_in_network (struct GAS_PROPORTIONAL_Handle *s,
1127                                  struct Network *n)
1128 {
1129   if (GNUNET_YES == s->bulk_lock)
1130   {
1131     s->bulk_requests++;
1132     return;
1133   }
1134
1135   if (NULL != n)
1136   {
1137     LOG (GNUNET_ERROR_TYPE_INFO,
1138         "Redistributing bandwidth in network %s with %u active and %u total addresses\n",
1139         GNUNET_ATS_print_network_type(n->type),
1140         n->active_addresses, n->total_addresses);
1141
1142     if (NULL != s->env->info_cb)
1143       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_START,
1144           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1145
1146     /* Distribute  */
1147     distribute_bandwidth(s, n);
1148
1149     if (NULL != s->env->info_cb)
1150       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_STOP,
1151           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1152     if (NULL != s->env->info_cb)
1153       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
1154           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1155
1156     /* Do propagation */
1157     propagate_bandwidth (s, n);
1158
1159     if (NULL != s->env->info_cb)
1160       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
1161           GAS_STAT_SUCCESS, GAS_INFO_PROP_SINGLE);
1162   }
1163   else
1164   {
1165     int i;
1166     if (NULL != s->env->info_cb)
1167       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_START,
1168           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1169     for (i = 0; i < s->network_count; i++)
1170     {
1171       /* Distribute */
1172       distribute_bandwidth(s, &s->network_entries[i]);
1173     }
1174
1175     if (NULL != s->env->info_cb)
1176       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_STOP,
1177           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1178     if (NULL != s->env->info_cb)
1179       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_START,
1180           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1181     for (i = 0; i < s->network_count; i++)
1182     {
1183       /* Do propagation */
1184       propagate_bandwidth(s, &s->network_entries[i]);
1185     }
1186     if (NULL != s->env->info_cb)
1187       s->env->info_cb(s->env->info_cb_cls, GAS_OP_SOLVE_UPDATE_NOTIFICATION_STOP,
1188           GAS_STAT_SUCCESS, GAS_INFO_PROP_ALL);
1189   }
1190 }
1191
1192
1193 /**
1194  * Update active address for a peer:
1195  * Check if active address exists and what the best address is, if addresses
1196  * are different switch
1197  *
1198  * @param s solver handle
1199  * @param peer the peer to check
1200  * return the new address or NULL if no update was performed
1201   */
1202 static const struct ATS_Address *
1203 update_active_address (struct GAS_PROPORTIONAL_Handle *s,
1204                        const struct GNUNET_PeerIdentity *peer)
1205 {
1206   struct ATS_Address *best_address;
1207   struct ATS_Address *current_address;
1208   struct AddressSolverInformation *asi;
1209   struct Network *net;
1210
1211   LOG (GNUNET_ERROR_TYPE_INFO,
1212        "Updating active address for peer `%s'\n",
1213        GNUNET_i2s (peer));
1214
1215   /* Find active address */
1216   current_address = get_active_address (s, s->addresses, peer);
1217
1218   LOG (GNUNET_ERROR_TYPE_INFO,
1219        "Peer `%s' has active address %p\n",
1220        GNUNET_i2s (peer),
1221        current_address);
1222
1223
1224   /* Find best address */
1225   best_address = get_best_address (s,s->addresses, peer);
1226
1227   LOG (GNUNET_ERROR_TYPE_INFO,
1228        "Peer `%s' has best address %p\n",
1229        GNUNET_i2s (peer), best_address);
1230
1231   if (NULL != current_address)
1232   {
1233     if ((NULL == best_address) || ((NULL != best_address) &&
1234         (GNUNET_NO == address_eq (current_address, best_address))))
1235     {
1236       /* We switch to a new address, mark old address as inactive */
1237       LOG (GNUNET_ERROR_TYPE_INFO,
1238           "Disabling previous %s address %p for peer `%s'\n",
1239           (GNUNET_NO == current_address->active) ? "inactive" : "active",
1240           current_address,
1241           GNUNET_i2s (peer));
1242
1243       asi = current_address->solver_information;
1244       GNUNET_assert (NULL != asi);
1245
1246       net = asi->network;
1247       asi->activated = GNUNET_TIME_UNIT_ZERO_ABS;
1248       current_address->active = GNUNET_NO; /* No active any longer */
1249 GNUNET_break (0);
1250       current_address->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1251       current_address->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1252
1253       if (GNUNET_SYSERR == addresse_decrement (s, net, GNUNET_NO, GNUNET_YES))
1254         GNUNET_break(0);
1255
1256       /* Update network of previous address */
1257       distribute_bandwidth_in_network (s, net);
1258     }
1259     if (NULL == best_address)
1260     {
1261       /* We previously had an active address, but now we cannot suggest one
1262        * Therefore we have to disconnect the peer */
1263
1264       LOG (GNUNET_ERROR_TYPE_INFO,
1265           "Disconnecting peer `%s' with previous %s address %p\n",
1266           GNUNET_i2s (peer),
1267           (GNUNET_NO == current_address->active) ? "inactive" : "active",
1268           current_address);
1269       s->bw_changed (s->bw_changed_cls, current_address);
1270     }
1271   }
1272
1273   if (NULL == best_address)
1274   {
1275     LOG (GNUNET_ERROR_TYPE_INFO, "Cannot suggest address for peer `%s'\n",
1276         GNUNET_i2s (peer));
1277     return NULL ;
1278   }
1279
1280   LOG (GNUNET_ERROR_TYPE_INFO, "Suggesting %s address %p for peer `%s'\n",
1281       (GNUNET_NO == best_address->active) ? "inactive" : "active", best_address,
1282       GNUNET_i2s (peer));
1283
1284   if ((NULL != current_address) &&
1285       (GNUNET_YES == address_eq (best_address, current_address)))
1286   {
1287     if (current_address->active == GNUNET_NO)
1288       GNUNET_break (0); /* Should never happen */
1289     return best_address; /* Same same */
1290   }
1291
1292   asi = best_address->solver_information;
1293   GNUNET_assert (NULL != asi);
1294   net = asi->network;
1295
1296   /* Mark address as active */
1297   asi->activated = GNUNET_TIME_absolute_get();
1298   best_address->active = GNUNET_YES;
1299   address_increment (s, net, GNUNET_NO, GNUNET_YES);
1300   LOG (GNUNET_ERROR_TYPE_INFO, "Address %p for peer `%s' is now active\n",
1301       best_address, GNUNET_i2s (peer));
1302   /* Distribute bandwidth */
1303   distribute_bandwidth_in_network (s, net);
1304   return best_address;
1305 }
1306
1307
1308 /**
1309  * Changes the preferences for a peer in the problem
1310  *
1311  * @param solver the solver handle
1312  * @param peer the peer to change the preference for
1313  * @param kind the kind to change the preference
1314  * @param pref_rel the normalized preference value for this kind over all clients
1315  */
1316 static void
1317 GAS_proportional_address_change_preference (void *solver,
1318                                             const struct GNUNET_PeerIdentity *peer,
1319                                             enum GNUNET_ATS_PreferenceKind kind,
1320                                             double pref_rel)
1321 {
1322   struct GAS_PROPORTIONAL_Handle *s = solver;
1323   struct ATS_Address *best_address;
1324   struct ATS_Address *active_address;
1325   struct AddressSolverInformation *asi;
1326
1327   GNUNET_assert(NULL != s);
1328   GNUNET_assert(NULL != peer);
1329
1330   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, peer))
1331     return; /* Peer is not requested */
1332
1333   /* This peer is requested, find best address */
1334   active_address = get_active_address(s, s->addresses, peer);
1335   best_address = (struct ATS_Address *) update_active_address (s, peer);
1336
1337   if ((NULL != best_address) && ((NULL != active_address) &&
1338       (GNUNET_YES == address_eq (active_address, best_address))))
1339   {
1340     asi = best_address->solver_information;
1341     GNUNET_assert (NULL != asi);
1342
1343     /* We sticked to the same address, therefore redistribute  */
1344     distribute_bandwidth_in_network (s, asi->network);
1345   }
1346 }
1347
1348
1349 /**
1350  * Get application feedback for a peer
1351  *
1352  * @param solver the solver handle
1353  * @param application the application
1354  * @param peer the peer to change the preference for
1355  * @param scope the time interval for this feedback: [now - scope .. now]
1356  * @param kind the kind to change the preference
1357  * @param score the score
1358  */
1359 static void
1360 GAS_proportional_address_preference_feedback (void *solver,
1361                                               void *application,
1362                                               const struct GNUNET_PeerIdentity *peer,
1363                                               const struct GNUNET_TIME_Relative scope,
1364                                               enum GNUNET_ATS_PreferenceKind kind,
1365                                               double score)
1366 {
1367   struct GAS_PROPORTIONAL_Handle *s = solver;
1368
1369   GNUNET_assert(NULL != peer);
1370   GNUNET_assert(NULL != s);
1371 }
1372
1373
1374 /**
1375  * Get the preferred address for a specific peer
1376  *
1377  * @param solver the solver handle
1378  * @param peer the identity of the peer
1379  * @return best address
1380  */
1381 static const struct ATS_Address *
1382 GAS_proportional_get_preferred_address (void *solver,
1383                                         const struct GNUNET_PeerIdentity *peer)
1384 {
1385   struct GAS_PROPORTIONAL_Handle *s = solver;
1386   const struct ATS_Address *best_address;
1387
1388
1389   GNUNET_assert(s != NULL);
1390   GNUNET_assert(peer != NULL);
1391
1392   /* Add to list of pending requests */
1393   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, peer))
1394   {
1395     GNUNET_assert(
1396         GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (s->requests, peer, NULL,
1397             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1398     LOG (GNUNET_ERROR_TYPE_INFO, "Start suggesting addresses for peer `%s'\n",
1399           GNUNET_i2s (peer));
1400   }
1401
1402   best_address = update_active_address (s, peer);
1403   if (s->bulk_lock > 0)
1404     return NULL; /* Do not suggest since bulk lock is pending */
1405
1406   return best_address;
1407 }
1408
1409
1410 /**
1411  * Stop notifying about address and bandwidth changes for this peer
1412  *
1413  * @param solver the solver handle
1414  * @param peer the peer
1415  */
1416 static void
1417 GAS_proportional_stop_get_preferred_address (void *solver,
1418                                              const struct GNUNET_PeerIdentity *peer)
1419 {
1420   struct GAS_PROPORTIONAL_Handle *s = solver;
1421   struct ATS_Address *cur;
1422   struct AddressSolverInformation *asi;
1423   struct Network *cur_net;
1424
1425   if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (s->requests, peer))
1426         {
1427     GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (s->requests,
1428         peer, NULL));
1429     LOG (GNUNET_ERROR_TYPE_INFO, "Stop suggesting addresses for peer `%s'\n",
1430           GNUNET_i2s (peer));
1431         }
1432
1433   cur = get_active_address (s, s->addresses, peer);
1434   if (NULL != cur)
1435   {
1436     LOG(GNUNET_ERROR_TYPE_INFO,
1437         "Disabling %s address %p for peer `%s'\n",
1438         (GNUNET_NO == cur->active) ? "inactive" : "active", cur,
1439         GNUNET_i2s (&cur->peer));
1440
1441     /* Disabling current address */
1442     asi = cur->solver_information;
1443     cur_net = asi->network ;
1444     asi->activated = GNUNET_TIME_UNIT_ZERO_ABS;
1445     cur->active = GNUNET_NO; /* No active any longer */
1446     cur->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1447     cur->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1448
1449     if (GNUNET_SYSERR == addresse_decrement (s, cur_net, GNUNET_NO, GNUNET_YES))
1450       GNUNET_break(0);
1451
1452     distribute_bandwidth_in_network (s, cur_net );
1453   }
1454   return;
1455 }
1456
1457
1458 /**
1459  * Remove an address from the solver
1460  *
1461  * @param solver the solver handle
1462  * @param address the address to remove
1463  * @param session_only delete only session not whole address
1464  */
1465 static void
1466 GAS_proportional_address_delete (void *solver,
1467                                  struct ATS_Address *address,
1468                                  int session_only)
1469 {
1470   struct GAS_PROPORTIONAL_Handle *s = solver;
1471   struct Network *net;
1472   struct AddressWrapper *aw;
1473   struct AddressSolverInformation *asi;
1474
1475   /* Remove an adress completely, we have to:
1476    * - Remove from specific network
1477    * - Decrease number of total addresses
1478    * - If active:
1479    *   - decrease number of active addreses
1480    *   - update quotas
1481    */
1482   asi = address->solver_information;
1483
1484   if (NULL == asi)
1485   {
1486     GNUNET_break (0);
1487     return;
1488   }
1489   net = asi->network;
1490
1491   if (GNUNET_NO == session_only)
1492   {
1493     LOG(GNUNET_ERROR_TYPE_INFO,
1494         "Deleting %s address %p for peer `%s' from network `%s' (total: %u/ active: %u)\n",
1495         (GNUNET_NO == address->active) ? "inactive" : "active", address,
1496         GNUNET_i2s (&address->peer), net->desc, net->total_addresses,
1497         net->active_addresses);
1498
1499     /* Remove address */
1500     addresse_decrement (s, net, GNUNET_YES, GNUNET_NO);
1501     for (aw = net->head; NULL != aw; aw = aw->next)
1502     {
1503       if (aw->addr == address)
1504         break;
1505     }
1506     if (NULL == aw)
1507     {
1508       GNUNET_break(0);
1509       return;
1510     }
1511     GNUNET_CONTAINER_DLL_remove(net->head, net->tail, aw);
1512     GNUNET_free(aw);
1513   }
1514   else
1515   {
1516     /* Remove session only: remove if active and update */
1517     LOG(GNUNET_ERROR_TYPE_INFO,
1518         "Deleting %s session %p for peer `%s' from network `%s' (total: %u/ active: %u)\n",
1519         (GNUNET_NO == address->active) ? "inactive" : "active", address,
1520         GNUNET_i2s (&address->peer), net->desc, net->total_addresses,
1521         net->active_addresses);
1522   }
1523
1524   if (GNUNET_YES == address->active)
1525   {
1526     /* Address was active, remove from network and update quotas*/
1527     address->active = GNUNET_NO;
1528
1529     address->assigned_bw_in = BANDWIDTH_ZERO;
1530     address->assigned_bw_out = BANDWIDTH_ZERO;
1531     asi->calculated_quota_in_NBO = htonl (0);
1532     asi->calculated_quota_out_NBO = htonl (0);
1533
1534     if (GNUNET_SYSERR == addresse_decrement (s, net, GNUNET_NO, GNUNET_YES))
1535       GNUNET_break(0);
1536     distribute_bandwidth_in_network (s, net);
1537
1538     if (NULL == update_active_address (s, &address->peer))
1539     {
1540       /* No alternative address found, disconnect peer */
1541       LOG (GNUNET_ERROR_TYPE_INFO,
1542           "Disconnecting peer `%s' after deleting previous %s address %p\n",
1543           GNUNET_i2s (&address->peer),
1544           (GNUNET_NO == address->active) ? "inactive" : "active",
1545               address);
1546       s->bw_changed (s->bw_changed_cls, address);
1547     }
1548   }
1549   if (GNUNET_NO == session_only)
1550   {
1551     GNUNET_free_non_null (address->solver_information);
1552     address->solver_information = NULL;
1553   }
1554
1555   LOG(GNUNET_ERROR_TYPE_INFO,
1556       "After deleting address now total %u and active %u addresses in network `%s'\n",
1557       net->total_addresses, net->active_addresses, net->desc);
1558
1559 }
1560
1561
1562 /**
1563  * Start a bulk operation
1564  *
1565  * @param solver the solver
1566  */
1567 static void
1568 GAS_proportional_bulk_start (void *solver)
1569 {
1570   struct GAS_PROPORTIONAL_Handle *s = solver;
1571
1572   LOG (GNUNET_ERROR_TYPE_DEBUG,
1573        "Locking solver for bulk operation ...\n");
1574   GNUNET_assert(NULL != solver);
1575   s->bulk_lock++;
1576 }
1577
1578
1579 /**
1580  * Bulk operation done
1581  */
1582 static void
1583 GAS_proportional_bulk_stop (void *solver)
1584 {
1585   struct GAS_PROPORTIONAL_Handle *s = solver;
1586
1587   LOG (GNUNET_ERROR_TYPE_DEBUG,
1588        "Unlocking solver from bulk operation ...\n");
1589   GNUNET_assert(NULL != solver);
1590
1591   if (s->bulk_lock < 1)
1592   {
1593     GNUNET_break(0);
1594     return;
1595   }
1596   s->bulk_lock--;
1597   if ((0 == s->bulk_lock) && (0 < s->bulk_requests))
1598   {
1599     LOG(GNUNET_ERROR_TYPE_INFO, "No lock pending, recalculating\n");
1600     distribute_bandwidth_in_network (s, NULL);
1601     s->bulk_requests = 0;
1602   }
1603 }
1604
1605
1606 /**
1607  * Add a new single address to a network
1608  *
1609  * @param solver the solver Handle
1610  * @param address the address to add
1611  * @param network network type of this address
1612  */
1613 static void
1614 GAS_proportional_address_add (void *solver,
1615                               struct ATS_Address *address,
1616                               uint32_t network);
1617
1618
1619 /**
1620  * Transport properties for this address have changed
1621  *
1622  * @param solver solver handle
1623  * @param address the address
1624  * @param type the ATSI type in HBO
1625  * @param abs_value the absolute value of the property
1626  * @param rel_value the normalized value
1627  */
1628 static void
1629 GAS_proportional_address_property_changed (void *solver,
1630                                            struct ATS_Address *address,
1631                                            uint32_t type,
1632                                            uint32_t abs_value,
1633                                            double rel_value)
1634 {
1635   struct GAS_PROPORTIONAL_Handle *s = solver;
1636   struct Network *n;
1637   struct AddressSolverInformation *asi;
1638   struct ATS_Address *best_address;
1639   struct ATS_Address *active_address;
1640
1641   GNUNET_assert(NULL != s);
1642   GNUNET_assert(NULL != address);
1643   asi = address->solver_information;
1644   if (NULL == asi)
1645   {
1646     GNUNET_break(0);
1647     return;
1648   }
1649
1650   n = asi->network;
1651   if (NULL == n)
1652   {
1653     GNUNET_break(0);
1654     return;
1655   }
1656
1657   LOG(GNUNET_ERROR_TYPE_INFO,
1658       "Property `%s' for peer `%s' address %p changed to %.2f \n",
1659       GNUNET_ATS_print_property_type (type), GNUNET_i2s (&address->peer),
1660       address, rel_value);
1661
1662   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1663     return; /* Peer is not requested */
1664
1665   /* This peer is requested, find active and best address */
1666   active_address = get_active_address(s, s->addresses, &address->peer);
1667   best_address = (struct ATS_Address *) update_active_address (s, &address->peer);
1668
1669   if ((NULL != best_address) && ((NULL != active_address) &&
1670       (GNUNET_YES == address_eq (active_address, best_address))))
1671   {
1672     asi = best_address->solver_information;
1673     GNUNET_assert (NULL != asi);
1674
1675     /* We sticked to the same address, therefore redistribute  */
1676     distribute_bandwidth_in_network (s, asi->network);
1677   }
1678 }
1679
1680 /**
1681  * Transport session for this address has changed
1682  *
1683  * NOTE: values in addresses are already updated
1684  *
1685  * @param solver solver handle
1686  * @param address the address
1687  * @param cur_session the current session
1688  * @param new_session the new session
1689  */
1690 static void
1691 GAS_proportional_address_session_changed (void *solver,
1692                                           struct ATS_Address *address,
1693                                           uint32_t cur_session,
1694                                           uint32_t new_session)
1695 {
1696   struct GAS_PROPORTIONAL_Handle *s = solver;
1697   struct ATS_Address *best_address;
1698   struct ATS_Address *active_address;
1699   struct AddressSolverInformation *asi;
1700
1701   if (cur_session != new_session)
1702   {
1703     LOG (GNUNET_ERROR_TYPE_DEBUG,
1704          "Session changed from %u to %u\n",
1705          cur_session,
1706          new_session);
1707   }
1708
1709   if (NULL == address->solver_information)
1710   {
1711     GNUNET_break (0);
1712     return;
1713   }
1714
1715   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1716     return; /* Peer is not requested */
1717
1718   /* This peer is requested, find active and best address */
1719   active_address = get_active_address(s, s->addresses, &address->peer);
1720   best_address = (struct ATS_Address *) update_active_address (s, &address->peer);
1721
1722   if ((NULL != best_address) && ((NULL != active_address) &&
1723       (GNUNET_YES == address_eq (active_address, best_address))))
1724   {
1725     asi = best_address->solver_information;
1726     GNUNET_assert (NULL != asi);
1727
1728     /* We sticked to the same address, therefore redistribute  */
1729     distribute_bandwidth_in_network (s, asi->network);
1730   }
1731 }
1732
1733
1734 /**
1735  * Usage for this address has changed
1736  *
1737  * NOTE: values in addresses are already updated
1738  *
1739  * @param solver solver handle
1740  * @param address the address
1741  * @param in_use usage state
1742  */
1743 static void
1744 GAS_proportional_address_inuse_changed (void *solver,
1745                                         struct ATS_Address *address,
1746                                         int in_use)
1747 {
1748   struct GAS_PROPORTIONAL_Handle *s = solver;
1749   struct Network *n;
1750   struct AddressSolverInformation *asi;
1751   struct ATS_Address *best_address;
1752   struct ATS_Address *active_address;
1753
1754   GNUNET_assert(NULL != s);
1755   GNUNET_assert(NULL != address);
1756   asi = address->solver_information;
1757   if (NULL == asi)
1758   {
1759     GNUNET_break(0);
1760     return;
1761   }
1762
1763   n = asi->network;
1764   if (NULL == n)
1765   {
1766     GNUNET_break(0);
1767     return;
1768   }
1769
1770   LOG(GNUNET_ERROR_TYPE_INFO,
1771       "Usage of peer `%s' address %p changed to %s \n",
1772       GNUNET_i2s (&address->peer), address,
1773       (GNUNET_YES == in_use) ? "YES" : "NO");
1774
1775   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1776     return; /* Peer is not requested */
1777
1778   /* This peer is requested, find active and best address */
1779   active_address = get_active_address(s, s->addresses, &address->peer);
1780   best_address = (struct ATS_Address *) update_active_address (s, &address->peer);
1781
1782   if ((NULL != best_address) && ((NULL != active_address) &&
1783       (GNUNET_YES == address_eq (active_address, best_address))))
1784   {
1785     asi = best_address->solver_information;
1786     GNUNET_assert (NULL != asi);
1787
1788     /* We sticked to the same address, therefore redistribute  */
1789     distribute_bandwidth_in_network (s, asi->network);
1790   }
1791 }
1792
1793 /**
1794  * Network scope for this address has changed
1795  *
1796  * NOTE: values in addresses are already updated
1797  *
1798  * @param solver solver handle
1799  * @param address the address
1800  * @param current_network the current network
1801  * @param new_network the new network
1802  */
1803 static void
1804 GAS_proportional_address_change_network (void *solver,
1805                                          struct ATS_Address *address,
1806                                          uint32_t current_network,
1807                                          uint32_t new_network)
1808 {
1809   struct GAS_PROPORTIONAL_Handle *s = solver;
1810   struct AddressSolverInformation *asi;
1811   int save_active = GNUNET_NO;
1812
1813   if (current_network == new_network)
1814   {
1815     GNUNET_break(0);
1816     return;
1817   }
1818
1819   asi = address->solver_information;
1820   if (NULL == asi)
1821   {
1822     GNUNET_break(0);
1823     return;
1824   }
1825
1826   /* Network changed */
1827   LOG(GNUNET_ERROR_TYPE_DEBUG,
1828       "Network type changed, moving %s address from `%s' to `%s'\n",
1829       (GNUNET_YES == address->active) ? "active" : "inactive",
1830       GNUNET_ATS_print_network_type (current_network),
1831       GNUNET_ATS_print_network_type (new_network));
1832
1833
1834   /* Start bulk to prevent disconnect */
1835   GAS_proportional_bulk_start(s);
1836
1837   save_active = address->active;
1838
1839   /* Disable and assign no bandwidth */
1840   address->active = GNUNET_NO;
1841   address->assigned_bw_in = BANDWIDTH_ZERO; /* no bandwidth assigned */
1842   address->assigned_bw_out = BANDWIDTH_ZERO; /* no bandwidth assigned */
1843
1844   /* Remove from old network */
1845   GAS_proportional_address_delete (solver, address, GNUNET_NO);
1846
1847   /* Set new network type */
1848   if (NULL == get_network (solver, new_network))
1849   {
1850     /* Address changed to invalid network... */
1851     LOG(GNUNET_ERROR_TYPE_ERROR,
1852         _("Invalid network type `%u' `%s': Disconnect!\n"), new_network,
1853         GNUNET_ATS_print_network_type (new_network));
1854     s->bw_changed (s->bw_changed_cls, address);
1855   }
1856   else
1857   {
1858     /* Add to new network and update*/
1859     GAS_proportional_address_add (solver, address, new_network);
1860   }
1861   GAS_proportional_bulk_stop (s);
1862
1863   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1864     return; /* Peer is not requested */
1865
1866   /* Find new address to suggest */
1867   if (GNUNET_YES == save_active)
1868   {
1869     /* No address available, therefore disconnect */
1870     if (NULL == update_active_address (s, &address->peer))
1871       s->bw_changed (s->bw_changed_cls, address);
1872   }
1873
1874 }
1875
1876 /**
1877  * Add a new single address to a network
1878  *
1879  * @param solver the solver Handle
1880  * @param address the address to add
1881  * @param network network type of this address
1882  */
1883 static void
1884 GAS_proportional_address_add (void *solver,
1885                               struct ATS_Address *address,
1886                               uint32_t network)
1887 {
1888   struct GAS_PROPORTIONAL_Handle *s = solver;
1889   struct Network *net = NULL;
1890   struct AddressWrapper *aw = NULL;
1891   struct AddressSolverInformation *asi;
1892
1893   GNUNET_assert(NULL != s);
1894   net = get_network (s, network);
1895   if (NULL == net)
1896   {
1897     GNUNET_break(0);
1898
1899     LOG(GNUNET_ERROR_TYPE_ERROR,
1900         "Unknown network %u `%s' for new address %p for peer `%s'\n",
1901         network, GNUNET_ATS_print_network_type(network),
1902         address, GNUNET_i2s(&address->peer));
1903
1904     return;
1905   }
1906
1907   aw = GNUNET_new (struct AddressWrapper);
1908   aw->addr = address;
1909   GNUNET_CONTAINER_DLL_insert(net->head, net->tail, aw);
1910   address_increment (s, net, GNUNET_YES, GNUNET_NO);
1911
1912   asi = GNUNET_new (struct AddressSolverInformation);
1913   asi->network = net;
1914   asi->calculated_quota_in_NBO = htonl (0);
1915   asi->calculated_quota_out_NBO = htonl (0);
1916   aw->addr->solver_information = asi;
1917
1918   LOG(GNUNET_ERROR_TYPE_INFO,
1919       "Adding new address %p for peer `%s', now total %u and active %u addresses in network `%s'\n",
1920       address, GNUNET_i2s(&address->peer), net->total_addresses, net->active_addresses, net->desc);
1921
1922   if (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (s->requests, &address->peer))
1923     return; /* Peer is not requested */
1924
1925   /* This peer is requested, find best address */
1926   update_active_address (s, &address->peer);
1927 }
1928
1929
1930
1931 /**
1932  * Function invoked when the plugin is loaded.
1933  *
1934  * @param cls[in,out] the `struct GNUNET_ATS_PluginEnvironment *` to use;
1935  *            modified to return the API functions (ugh).
1936  * @return the `struct GAS_PROPORTIONAL_Handle` to pass as a closure
1937  */
1938 void *
1939 libgnunet_plugin_ats_proportional_init (void *cls)
1940 {
1941   struct GNUNET_ATS_PluginEnvironment *env = cls;
1942   struct GAS_PROPORTIONAL_Handle *s;
1943   struct Network * cur;
1944   char * net_str[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
1945   float f_tmp;
1946   int c;
1947
1948   GNUNET_assert (NULL != env);
1949   GNUNET_assert (NULL != env->cfg);
1950   GNUNET_assert (NULL != env->bandwidth_changed_cb);
1951   GNUNET_assert (NULL != env->get_preferences);
1952   GNUNET_assert (NULL != env->get_property);
1953
1954   s = GNUNET_new (struct GAS_PROPORTIONAL_Handle);
1955   s->env = env;
1956   env->sf.s_add = &GAS_proportional_address_add;
1957   env->sf.s_address_update_property = &GAS_proportional_address_property_changed;
1958   env->sf.s_address_update_session = &GAS_proportional_address_session_changed;
1959   env->sf.s_address_update_inuse = &GAS_proportional_address_inuse_changed;
1960   env->sf.s_address_update_network = &GAS_proportional_address_change_network;
1961   env->sf.s_get = &GAS_proportional_get_preferred_address;
1962   env->sf.s_get_stop = &GAS_proportional_stop_get_preferred_address;
1963   env->sf.s_pref = &GAS_proportional_address_change_preference;
1964   env->sf.s_feedback = &GAS_proportional_address_preference_feedback;
1965   env->sf.s_del = &GAS_proportional_address_delete;
1966   env->sf.s_bulk_start = &GAS_proportional_bulk_start;
1967   env->sf.s_bulk_stop = &GAS_proportional_bulk_stop;
1968
1969   s->stats = (struct GNUNET_STATISTICS_Handle *) env->stats;
1970   s->bw_changed = env->bandwidth_changed_cb;
1971   s->bw_changed_cls = env->bw_changed_cb_cls;
1972   s->get_preferences = env->get_preferences;
1973   s->get_preferences_cls = env->get_preference_cls;
1974   s->get_properties = env->get_property;
1975   s->get_properties_cls = env->get_property_cls;
1976   s->network_count = env->network_count;
1977   s->network_entries = GNUNET_malloc (env->network_count * sizeof (struct Network));
1978
1979   /* Init */
1980   s->active_addresses = 0;
1981   s->total_addresses = 0;
1982   s->bulk_lock = GNUNET_NO;
1983   s->addresses = env->addresses;
1984   s->requests = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
1985
1986   s->stability_factor = PROP_STABILITY_FACTOR;
1987   if (GNUNET_SYSERR !=
1988       GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
1989                                             "PROP_STABILITY_FACTOR", &f_tmp))
1990   {
1991     if ((f_tmp < 1.0) || (f_tmp > 2.0))
1992     {
1993       LOG (GNUNET_ERROR_TYPE_ERROR,
1994            _("Invalid %s configuration %f \n"),
1995            "PROP_STABILITY_FACTOR",
1996            f_tmp);
1997     }
1998     else
1999     {
2000       s->stability_factor = f_tmp;
2001       LOG (GNUNET_ERROR_TYPE_INFO,
2002            "Using %s of %.3f\n",
2003            "PROP_STABILITY_FACTOR", f_tmp);
2004     }
2005   }
2006
2007   s->prop_factor = PROPORTIONALITY_FACTOR;
2008   if (GNUNET_SYSERR !=
2009       GNUNET_CONFIGURATION_get_value_float (env->cfg, "ats",
2010                                             "PROP_STABILITY_FACTOR", &f_tmp))
2011   {
2012     if (f_tmp < 1.0)
2013     {
2014       LOG (GNUNET_ERROR_TYPE_ERROR,
2015            _("Invalid %s configuration %f \n"),
2016            "PROP_PROPORTIONALITY_FACTOR", f_tmp);
2017     }
2018     else
2019     {
2020       s->prop_factor = f_tmp;
2021       LOG (GNUNET_ERROR_TYPE_INFO,
2022            "Using %s of %.3f\n",
2023            "PROP_PROPORTIONALITY_FACTOR", f_tmp);
2024     }
2025   }
2026
2027   for (c = 0; c < env->network_count; c++)
2028   {
2029     cur = &s->network_entries[c];
2030     cur->total_addresses = 0;
2031     cur->active_addresses = 0;
2032     cur->type = env->networks[c];
2033     cur->total_quota_in = env->in_quota[c];
2034     cur->total_quota_out = env->out_quota[c];
2035     cur->desc = net_str[c];
2036     GNUNET_asprintf (&cur->stat_total,
2037         "# ATS addresses %s total", cur->desc);
2038     GNUNET_asprintf (&cur->stat_active,
2039         "# ATS active addresses %s total", cur->desc);
2040     LOG (GNUNET_ERROR_TYPE_INFO,
2041          "Added network %u `%s' (%llu/%llu)\n",
2042         c, cur->desc, cur->total_quota_in, cur->total_quota_out);
2043   }
2044   return s;
2045 }
2046
2047
2048 /* end of plugin_ats_proportional.c */