src/ats/gnunet-service-ats_addresses.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2011 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file ats/gnunet-service-ats_addresses.c
  23  * @brief ats service address management
  24  * @author Matthias Wachs
  25  * @author Christian Grothoff
  26  */
  27 #include "platform.h"
  28 #include "gnunet_ats_service.h"
  29 #include "gnunet-service-ats.h"
  30 #include "gnunet-service-ats_addresses.h"
  31 #include "gnunet-service-ats_performance.h"
  32 #include "gnunet-service-ats_scheduling.h"
  33 #include "gnunet-service-ats_reservations.h"
  34 #if HAVE_LIBGLPK
  35 #include "gnunet-service-ats_addresses_mlp.h"
  36 #endif
  37 #include "gnunet-service-ats_addresses_simplistic.h"
  38
  39 #define ATS_BLOCKING_DELTA GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100)
  40
  41
  42 /**
  43  * Available ressource assignment modes
  44  */
  45 enum ATS_Mode
  46 {
  47   /*
  48    * Simplistic mode:
  49    *
  50    * Assign each peer an equal amount of bandwidth (bw)
  51    *
  52    * bw_per_peer = bw_total / #active addresses
  53    */
  54   MODE_SIMPLISTIC,
  55
  56   /*
  57    * MLP mode:
  58    *
  59    * Solve ressource assignment as an optimization problem
  60    * Uses an mixed integer programming solver
  61    */
  62   MODE_MLP
  63 };
  64
  65 static struct GNUNET_CONTAINER_MultiHashMap *addresses;
  66
  67 static void *solver;
  68
  69 static unsigned long long wan_quota_in;
  70
  71 static unsigned long long wan_quota_out;
  72
  73 static unsigned int active_addr_count;
  74
  75 static int ats_mode;
  76
  77 static int running;
  78
  79
  80 static unsigned int
  81 assemble_ats_information (struct ATS_Address *aa,  struct GNUNET_ATS_Information **dest)
  82 {
  83   unsigned int ats_count = GNUNET_ATS_PropertyCount - 1;
  84   struct GNUNET_ATS_Information *ats = GNUNET_malloc (ats_count * sizeof (struct GNUNET_ATS_Information));
  85   (*dest) = ats;
  86
  87   ats[0].type = ntohl(GNUNET_ATS_UTILIZATION_UP);
  88   ats[0].value = aa->atsp_utilization_out.value__;
  89   ats[1].type = ntohl(GNUNET_ATS_UTILIZATION_DOWN);
  90   ats[1].value = aa->atsp_utilization_in.value__;
  91   ats[2].type = ntohl(GNUNET_ATS_NETWORK_TYPE);
  92   ats[2].value = ntohl(aa->atsp_network_type);
  93   ats[3].type = ntohl(GNUNET_ATS_QUALITY_NET_DELAY);
  94   ats[3].value = ntohl(aa->atsp_latency.rel_value);
  95   ats[4].type = ntohl(GNUNET_ATS_QUALITY_NET_DISTANCE);
  96   ats[4].value = ntohl(aa->atsp_distance);
  97   ats[5].type = ntohl(GNUNET_ATS_COST_WAN);
  98   ats[5].value = ntohl (aa->atsp_cost_wan);
  99   ats[6].type = ntohl(GNUNET_ATS_COST_LAN);
 100   ats[6].value = ntohl (aa->atsp_cost_lan);
 101   ats[7].type = ntohl(GNUNET_ATS_COST_WLAN);
 102   ats[7].value = ntohl (aa->atsp_cost_wlan);
 103   return ats_count;
 104 }
 105
 106 static void
 107 send_bw_notification (struct ATS_Address *aa)
 108 {
 109   struct GNUNET_ATS_Information *ats;
 110   uint32_t ats_count;
 111
 112   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New bandwidth for peer %s is %u/%u\n",
 113               GNUNET_i2s (&aa->peer), ntohl (aa->assigned_bw_in.value__),
 114               ntohl (aa->assigned_bw_out.value__));
 115   ats_count = assemble_ats_information (aa, &ats);
 116
 117   GAS_scheduling_transmit_address_suggestion (&aa->peer, aa->plugin, aa->addr,
 118                                               aa->addr_len, aa->session_id,
 119                                               ats, ats_count,
 120                                               aa->assigned_bw_out,
 121                                               aa->assigned_bw_in);
 122   GAS_reservations_set_bandwidth (&aa->peer, aa->assigned_bw_in);
 123   GAS_performance_notify_all_clients (&aa->peer, aa->plugin, aa->addr, aa->addr_len,
 124                                   aa->active,
 125                                   ats, ats_count, aa->assigned_bw_out,
 126                                   aa->assigned_bw_in);
 127   GNUNET_free (ats);
 128 }
 129
 130 /**
 131  * Update a bandwidth assignment for a peer.  This trivial method currently
 132  * simply assigns the same share to all active connections.
 133  *
 134  * @param cls unused
 135  * @param key unused
 136  * @param value the 'struct ATS_Address'
 137  * @return GNUNET_OK (continue to iterate)
 138  */
 139 static int
 140 update_bw_simple_it (void *cls, const struct GNUNET_HashCode * key, void *value)
 141 {
 142   struct ATS_Address *aa = value;
 143
 144   if (GNUNET_YES != aa->active)
 145     return GNUNET_OK;
 146   GNUNET_assert (active_addr_count > 0);
 147
 148
 149   /* Simple method */
 150   aa->assigned_bw_in.value__ = htonl (wan_quota_in / active_addr_count);
 151   aa->assigned_bw_out.value__ = htonl (wan_quota_out / active_addr_count);
 152
 153   send_bw_notification (aa);
 154
 155   return GNUNET_OK;
 156 }
 157
 158
 159 /**
 160  * Some (significant) input changed, recalculate bandwidth assignment
 161  * for all peers.
 162  */
 163 static void
 164 recalculate_assigned_bw ()
 165 {
 166   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 167               "Recalculating bandwidth for all active connections\n");
 168   GNUNET_STATISTICS_update (GSA_stats, "# bandwidth recalculations performed",
 169                             1, GNUNET_NO);
 170   GNUNET_STATISTICS_set (GSA_stats, "# active addresses", active_addr_count,
 171                          GNUNET_NO);
 172
 173   GNUNET_CONTAINER_multihashmap_iterate (addresses, &update_bw_simple_it, NULL);
 174 }
 175
 176 /**
 177  * Free the given address
 178  * @param addr address to destroy
 179  */
 180 static void
 181 free_address (struct ATS_Address *addr)
 182 {
 183   GNUNET_free_non_null (addr->ats);
 184   GNUNET_free (addr->plugin);
 185   GNUNET_free (addr);
 186 }
 187
 188 /**
 189  * Create a ATS_address with the given information
 190  * @param peer peer
 191  * @param plugin_name plugin
 192  * @param plugin_addr address
 193  * @param plugin_addr_len address length
 194  * @param session_id session
 195  * @return the ATS_Address
 196  */
 197 static struct ATS_Address *
 198 create_address (const struct GNUNET_PeerIdentity *peer,
 199                 const char *plugin_name,
 200                 const void *plugin_addr, size_t plugin_addr_len,
 201                 uint32_t session_id)
 202 {
 203   struct ATS_Address *aa = NULL;
 204
 205   aa = GNUNET_malloc (sizeof (struct ATS_Address) + plugin_addr_len);
 206   aa->peer = *peer;
 207   aa->addr_len = plugin_addr_len;
 208   aa->addr = &aa[1];
 209   memcpy (&aa[1], plugin_addr, plugin_addr_len);
 210   aa->plugin = GNUNET_strdup (plugin_name);
 211   aa->session_id = session_id;
 212   return aa;
 213 }
 214
 215
 216 /**
 217  * Destroy the given address.
 218  *
 219  * @param addr address to destroy
 220  * @return GNUNET_YES if bandwidth allocations should be recalcualted
 221  */
 222 static int
 223 destroy_address (struct ATS_Address *addr)
 224 {
 225   int ret;
 226
 227   ret = GNUNET_NO;
 228   GNUNET_assert (GNUNET_YES ==
 229                  GNUNET_CONTAINER_multihashmap_remove (addresses,
 230                                                        &addr->peer.hashPubKey,
 231                                                        addr));
 232
 233 #if HAVE_LIBGLPK
 234   if (ats_mode == MODE_MLP)
 235     GAS_mlp_address_delete (solver, addresses, addr);
 236 #endif
 237
 238   if (GNUNET_YES == addr->active)
 239   {
 240     active_addr_count--;
 241     addr->active = GNUNET_NO;
 242     ret = GNUNET_YES;
 243   }
 244   free_address (addr);
 245   return ret;
 246 }
 247
 248
 249 struct CompareAddressContext
 250 {
 251   const struct ATS_Address *search;
 252
 253   /* exact_address != NULL if address and session is equal */
 254   struct ATS_Address *exact_address;
 255   /* exact_address != NULL if address and session is 0 */
 256   struct ATS_Address *base_address;
 257 };
 258
 259
 260 static int
 261 compare_address_it (void *cls, const struct GNUNET_HashCode * key, void *value)
 262 {
 263   struct CompareAddressContext *cac = cls;
 264   struct ATS_Address *aa = value;
 265
 266   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Comparing peer %4s: address length %u session %u <-> address length %u session %u\n",
 267       GNUNET_h2s (key),
 268       aa->addr_len, aa->session_id,
 269       cac->search->addr_len, cac->search->session_id);
 270
 271   /* Find an matching exact address:
 272    *
 273    * Compare by:
 274    * aa->addr_len == cac->search->addr_len
 275    * aa->plugin == cac->search->plugin
 276    * aa->addr == cac->search->addr
 277    * aa->session == cac->search->session
 278    *
 279    * return as exact address
 280    */
 281   if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin)))
 282   {
 283       if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == cac->search->session_id))
 284         cac->exact_address = aa;
 285   }
 286
 287   /* Find an matching base address:
 288    *
 289    * Properties:
 290    *
 291    * aa->session_id == 0
 292    *
 293    * Compare by:
 294    * aa->addr_len == cac->search->addr_len
 295    * aa->plugin == cac->search->plugin
 296    * aa->addr == cac->search->addr
 297    *
 298    * return as base address
 299    */
 300   if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin)))
 301   {
 302       if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == 0))
 303         cac->base_address = aa;
 304   }
 305
 306   /* Find an matching exact address based on session:
 307    *
 308    * Properties:
 309    *
 310    * cac->search->addr_len == 0
 311    *
 312    * Compare by:
 313    * aa->plugin == cac->search->plugin
 314    * aa->session_id == cac->search->session_id
 315    *
 316    * return as exact address
 317    */
 318   if (0 == cac->search->addr_len)
 319   {
 320       if ((0 == strcmp (aa->plugin, cac->search->plugin)) && (aa->session_id == cac->search->session_id))
 321         cac->exact_address = aa;
 322   }
 323
 324   if (cac->exact_address == NULL)
 325     return GNUNET_YES; /* Continue iteration to find exact address */
 326   else
 327     return GNUNET_NO; /* Stop iteration since we have an exact address */
 328 }
 329
 330
 331 /**
 332  * Find an existing equivalent address record.
 333  * Compares by peer identity and network address OR by session ID
 334  * (one of the two must match).
 335  *
 336  * @param peer peer to lookup addresses for
 337  * @param addr existing address record
 338  * @return existing address record, NULL for none
 339  */
 340 struct ATS_Address *
 341 find_address (const struct GNUNET_PeerIdentity *peer,
 342               const struct ATS_Address *addr)
 343 {
 344   struct CompareAddressContext cac;
 345
 346   cac.exact_address = NULL;
 347   cac.base_address = NULL;
 348   cac.search = addr;
 349   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
 350                                               &compare_address_it, &cac);
 351
 352 #if 0
 353   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 354               "Found exact address: %s           base address: %s\n",
 355               (cac.exact_address != NULL) ? "YES" : "NO",
 356               (cac.base_address != NULL) ? "YES" : "NO");
 357 #endif
 358   if (cac.exact_address == NULL)
 359     return cac.base_address;
 360   return cac.exact_address;
 361 }
 362
 363
 364 static struct ATS_Address *
 365 lookup_address (const struct GNUNET_PeerIdentity *peer,
 366                 const char *plugin_name, const void *plugin_addr,
 367                 size_t plugin_addr_len, uint32_t session_id,
 368                 const struct GNUNET_ATS_Information *atsi,
 369                 uint32_t atsi_count)
 370 {
 371   struct ATS_Address *aa;
 372   struct ATS_Address *old;
 373
 374   aa = create_address (peer,
 375                        plugin_name,
 376                        plugin_addr, plugin_addr_len,
 377                        session_id);
 378
 379   aa->mlp_information = NULL;
 380   aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information));
 381   aa->ats_count = atsi_count;
 382   memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information));
 383
 384   /* Get existing address or address with session == 0 */
 385   old = find_address (peer, aa);
 386   free_address (aa);
 387   if (old == NULL)
 388   {
 389     return NULL;
 390   }
 391   else if (old->session_id != session_id)
 392   {
 393     return NULL;
 394   }
 395   return old;
 396 }
 397
 398
 399 #if DEADCODE
 400 static int
 401 compare_address_session_it (void *cls, const struct GNUNET_HashCode * key, void *value)
 402 {
 403   struct CompareAddressContext *cac = cls;
 404   struct ATS_Address *aa = value;
 405
 406   if ((aa->addr_len == cac->search->addr_len) && (0 == strcmp (aa->plugin, cac->search->plugin)))
 407   {
 408       if ((0 == memcmp (aa->addr, cac->search->addr, aa->addr_len)) && (aa->session_id == cac->search->session_id))
 409       {
 410         cac->exact_address = aa;
 411         return GNUNET_NO;
 412       }
 413   }
 414   return GNUNET_YES;
 415 }
 416
 417
 418 /**
 419  * Find an existing equivalent address record.
 420  * Compares by peer identity and network address AND by session ID
 421  * (one of the two must match).
 422  *
 423  * @param peer peer to lookup addresses for
 424  * @param addr existing address record
 425  * @return existing address record, NULL for none
 426  */
 427 static struct ATS_Address *
 428 find_exact_address (const struct GNUNET_PeerIdentity *peer,
 429               const struct ATS_Address *addr)
 430 {
 431   struct CompareAddressContext cac;
 432
 433   cac.exact_address = NULL;
 434   cac.search = addr;
 435   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
 436                                               &compare_address_session_it, &cac);
 437   return cac.exact_address;
 438 }
 439 #endif
 440
 441
 442 void
 443 GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
 444                       const char *plugin_name, const void *plugin_addr,
 445                       size_t plugin_addr_len, uint32_t session_id,
 446                       const struct GNUNET_ATS_Information *atsi,
 447                       uint32_t atsi_count)
 448 {
 449   struct ATS_Address *aa;
 450   struct ATS_Address *old;
 451
 452   if (GNUNET_NO == running)
 453     return;
 454
 455   GNUNET_assert (NULL != addresses);
 456
 457   aa = create_address (peer,
 458                        plugin_name,
 459                        plugin_addr, plugin_addr_len,
 460                        session_id);
 461
 462   aa->mlp_information = NULL;
 463   aa->ats = GNUNET_malloc (atsi_count * sizeof (struct GNUNET_ATS_Information));
 464   aa->ats_count = atsi_count;
 465   memcpy (aa->ats, atsi, atsi_count * sizeof (struct GNUNET_ATS_Information));
 466
 467   /* Get existing address or address with session == 0 */
 468   old = find_address (peer, aa);
 469   if (old == NULL)
 470   {
 471     /* We have a new address */
 472     GNUNET_assert (GNUNET_OK ==
 473                    GNUNET_CONTAINER_multihashmap_put (addresses,
 474                                                       &peer->hashPubKey, aa,
 475                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 476     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new address for peer `%s' session id %u, %p\n",
 477                 GNUNET_i2s (peer), session_id, aa);
 478     return;
 479   }
 480
 481   if (old->session_id == 0)
 482   {
 483     /* We have a base address with out an session, update this address */
 484     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 485               "Updated existing address for peer `%s' %p with new session %u\n",
 486               GNUNET_i2s (peer), old, session_id);
 487     GNUNET_free_non_null (old->ats);
 488     old->session_id = session_id;
 489     old->ats = NULL;
 490     old->ats_count = 0;
 491     old->ats = aa->ats;
 492     old->ats_count = aa->ats_count;
 493     GNUNET_free (aa->plugin);
 494     GNUNET_free (aa);
 495     return;
 496   }
 497
 498   /* This address and session is already existing */
 499   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 500             "Added already existing address for peer `%s' `%s' %p with new session %u\n",
 501             GNUNET_i2s (peer), plugin_name, session_id);
 502   GNUNET_break (0);
 503 }
 504
 505
 506 void
 507 GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
 508                       const char *plugin_name, const void *plugin_addr,
 509                       size_t plugin_addr_len, uint32_t session_id,
 510                       const struct GNUNET_ATS_Information *atsi,
 511                       uint32_t atsi_count)
 512 {
 513   struct ATS_Address *old;
 514   uint32_t i;
 515
 516   if (GNUNET_NO == running)
 517     return;
 518
 519   GNUNET_assert (NULL != addresses);
 520
 521   /* Get existing address */
 522   old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len,
 523                        session_id, atsi, atsi_count);
 524   if (old == NULL)
 525   {
 526     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Tried to update unknown address for peer `%s' `%s' session id %u\n",
 527                 GNUNET_i2s (peer), plugin_name, session_id);
 528     GNUNET_break (0);
 529     return;
 530   }
 531
 532   for (i = 0; i < atsi_count; i++)
 533     switch (ntohl (atsi[i].type))
 534     {
 535     case GNUNET_ATS_UTILIZATION_UP:
 536       old->atsp_utilization_out.value__ = atsi[i].value;
 537       break;
 538     case GNUNET_ATS_UTILIZATION_DOWN:
 539       old->atsp_utilization_in.value__ = atsi[i].value;
 540       break;
 541     case GNUNET_ATS_QUALITY_NET_DELAY:
 542       old->atsp_latency.rel_value = ntohl (atsi[i].value);
 543       break;
 544     case GNUNET_ATS_QUALITY_NET_DISTANCE:
 545       old->atsp_distance = ntohl (atsi[i].value);
 546       break;
 547     case GNUNET_ATS_COST_WAN:
 548       old->atsp_cost_wan = ntohl (atsi[i].value);
 549       break;
 550     case GNUNET_ATS_COST_LAN:
 551       old->atsp_cost_lan = ntohl (atsi[i].value);
 552       break;
 553     case GNUNET_ATS_COST_WLAN:
 554       old->atsp_cost_wlan = ntohl (atsi[i].value);
 555       break;
 556     case GNUNET_ATS_NETWORK_TYPE:
 557       old->atsp_network_type = ntohl (atsi[i].value);
 558       break;
 559
 560     default:
 561       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 562                   "Received unsupported ATS type %u\n", ntohl (atsi[i].type));
 563       GNUNET_break (0);
 564       break;
 565     }
 566 #if HAVE_LIBGLPK
 567   if (ats_mode == MODE_MLP)
 568     GAS_mlp_address_update (solver, addresses, old);
 569 #endif
 570 }
 571
 572
 573 /**
 574  * Delete an address
 575  *
 576  * If session != 0, just the session is deleted, the address itself still exists
 577  * If session == 0, remove full address
 578  * If session == 0 and addrlen == 0, destroy inbound address
 579  *
 580  * @param cls unused
 581  * @param key unused
 582  * @param value the 'struct ATS_Address'
 583  * @return GNUNET_OK (continue to iterate)
 584  */
 585 static int
 586 destroy_by_session_id (void *cls, const struct GNUNET_HashCode * key, void *value)
 587 {
 588   const struct ATS_Address *info = cls;
 589   struct ATS_Address *aa = value;
 590
 591   GNUNET_assert (0 ==
 592                  memcmp (&aa->peer, &info->peer,
 593                          sizeof (struct GNUNET_PeerIdentity)));
 594   /* session == 0, remove full address  */
 595   if ((info->session_id == 0) && (0 == strcmp (info->plugin, aa->plugin)) &&
 596       (aa->addr_len == info->addr_len) &&
 597       (0 == memcmp (info->addr, aa->addr, aa->addr_len)))
 598   {
 599
 600     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 601                 "Deleting address for peer `%s': `%s' %u\n",
 602                 GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id);
 603
 604     if (GNUNET_YES == destroy_address (aa))
 605       recalculate_assigned_bw ();
 606     return GNUNET_OK;
 607   }
 608   /* session != 0, just remove session */
 609   if (aa->session_id != info->session_id)
 610     return GNUNET_OK;           /* irrelevant */
 611   if (aa->session_id != 0)
 612     GNUNET_break (0 == strcmp (info->plugin, aa->plugin));
 613   /* session died */
 614   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 615               "Deleting session for peer `%s': `%s' %u\n",
 616               GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id);
 617   aa->session_id = 0;
 618
 619   if (GNUNET_YES == aa->active)
 620   {
 621     aa->active = GNUNET_NO;
 622     active_addr_count--;
 623     recalculate_assigned_bw ();
 624   }
 625
 626   /* session == 0 and addrlen == 0 : destroy address */
 627   if (aa->addr_len == 0)
 628   {
 629     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 630                 "Deleting session and address for peer `%s': `%s' %u\n",
 631                 GNUNET_i2s (&aa->peer), aa->plugin, aa->session_id);
 632     (void) destroy_address (aa);
 633   }
 634   else
 635   {
 636     /* session was set to 0, update address */
 637 #if HAVE_LIBGLPK
 638   if (ats_mode == MODE_MLP)
 639     GAS_mlp_address_update (solver, addresses, aa);
 640 #endif
 641   }
 642
 643   return GNUNET_OK;
 644 }
 645
 646
 647 void
 648 GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
 649                        const char *plugin_name, const void *plugin_addr,
 650                        size_t plugin_addr_len, uint32_t session_id)
 651 {
 652   struct ATS_Address *aa;
 653   struct ATS_Address *old;
 654
 655   if (GNUNET_NO == running)
 656     return;
 657
 658   /* Get existing address */
 659   old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len,
 660                        session_id, NULL, 0);
 661   if (old == NULL)
 662   {
 663     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Tried to destroy unknown address for peer `%s' `%s' session id %u\n",
 664                 GNUNET_i2s (peer), plugin_name, session_id);
 665     return;
 666   }
 667
 668
 669   GNUNET_break (0 < strlen (plugin_name));
 670   aa = create_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id);
 671
 672   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
 673                                               &destroy_by_session_id, aa);
 674
 675   free_address (aa);
 676 }
 677
 678
 679 /**
 680  * Find a "good" address to use for a peer.  If we already have an existing
 681  * address, we stick to it.  Otherwise, we pick by lowest distance and then
 682  * by lowest latency.
 683  *
 684  * @param cls the 'struct ATS_Address**' where we store the result
 685  * @param key unused
 686  * @param value another 'struct ATS_Address*' to consider using
 687  * @return GNUNET_OK (continue to iterate)
 688  */
 689 static int
 690 find_address_it (void *cls, const struct GNUNET_HashCode * key, void *value)
 691 {
 692   struct ATS_Address **ap = cls;
 693   struct ATS_Address *aa = (struct ATS_Address *) value;
 694   struct ATS_Address *ab = *ap;
 695   struct GNUNET_TIME_Absolute now;
 696
 697   now = GNUNET_TIME_absolute_get();
 698
 699   if (aa->blocked_until.abs_value == GNUNET_TIME_absolute_max (now, aa->blocked_until).abs_value)
 700   {
 701     /* This address is blocked for suggestion */
 702     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 703                 "Address %p blocked for suggestion for %llu ms \n",
 704                 aa,
 705                 GNUNET_TIME_absolute_get_difference(now, aa->blocked_until).rel_value);
 706     return GNUNET_OK;
 707   }
 708
 709   aa->block_interval = GNUNET_TIME_relative_add (aa->block_interval, ATS_BLOCKING_DELTA);
 710   aa->blocked_until = GNUNET_TIME_absolute_add (now, aa->block_interval);
 711
 712   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 713               "Address %p ready for suggestion, block interval now %llu \n", aa, aa->block_interval);
 714
 715   /* FIXME this is a hack */
 716
 717
 718   if (NULL != ab)
 719   {
 720     if ((0 == strcmp (ab->plugin, "tcp")) &&
 721         (0 == strcmp (aa->plugin, "tcp")))
 722     {
 723       if ((0 != ab->addr_len) &&
 724           (0 == aa->addr_len))
 725       {
 726         /* saved address was an outbound address, but we have an inbound address */
 727         *ap = aa;
 728         return GNUNET_OK;
 729       }
 730       if (0 == ab->addr_len)
 731       {
 732         /* saved address was an inbound address, so do not overwrite */
 733         return GNUNET_OK;
 734       }
 735     }
 736   }
 737   /* FIXME end of hack */
 738
 739   if (NULL == ab)
 740   {
 741     *ap = aa;
 742     return GNUNET_OK;
 743   }
 744   if ((ntohl (ab->assigned_bw_in.value__) == 0) &&
 745       (ntohl (aa->assigned_bw_in.value__) > 0))
 746   {
 747     /* stick to existing connection */
 748     *ap = aa;
 749     return GNUNET_OK;
 750   }
 751   if (ab->atsp_distance > aa->atsp_distance)
 752   {
 753     /* user shorter distance */
 754     *ap = aa;
 755     return GNUNET_OK;
 756   }
 757   if (ab->atsp_latency.rel_value > aa->atsp_latency.rel_value)
 758   {
 759     /* user lower latency */
 760     *ap = aa;
 761     return GNUNET_OK;
 762   }
 763   /* don't care */
 764   return GNUNET_OK;
 765 }
 766
 767
 768 int
 769 GAS_addresses_in_use (const struct GNUNET_PeerIdentity *peer,
 770                       const char *plugin_name, const void *plugin_addr,
 771                       size_t plugin_addr_len, uint32_t session_id, int in_use)
 772 {
 773 #if DEBUG_ATS
 774   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 775               "Received `%s' message for peer `%s': %i\n", "ADDRESS_IN_USE",
 776               GNUNET_i2s (peer), in_use);
 777 #endif
 778
 779   struct ATS_Address *old;
 780
 781   if (GNUNET_NO == running)
 782     return GNUNET_SYSERR;
 783
 784   old = lookup_address (peer, plugin_name, plugin_addr, plugin_addr_len, session_id, NULL, 0);
 785   if (NULL == old)
 786   {
 787     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 788                 "Trying to set unknown address `%s', %s %u %s \n",
 789                 GNUNET_i2s (peer),
 790                 plugin_name, session_id,
 791                 (GNUNET_NO == in_use) ? "NO" : "YES");
 792     GNUNET_break (0);
 793     return GNUNET_SYSERR;
 794   }
 795   if (old->used == in_use)
 796   {
 797     GNUNET_break (0);
 798     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 799                 "Address in use called multiple times for peer `%s': %s -> %s \n",
 800                 GNUNET_i2s (peer),
 801                 (GNUNET_NO == old->used) ? "NO" : "YES",
 802                 (GNUNET_NO == in_use) ? "NO" : "YES");
 803     return GNUNET_SYSERR;
 804   }
 805   old->used = in_use;
 806 #if HAVE_LIBGLPK
 807   if (ats_mode == MODE_MLP)
 808      GAS_mlp_address_update (solver, addresses, old);
 809 #endif
 810   return GNUNET_OK;
 811 }
 812
 813
 814 static void
 815 request_address_mlp (const struct GNUNET_PeerIdentity *peer)
 816 {
 817   struct ATS_Address *aa;
 818   aa = NULL;
 819
 820 #if HAVE_GLPK
 821   /* Get preferred address from MODE_MLP */
 822   struct ATS_PreferedAddress * paddr = NULL;
 823   paddr = GAS_mlp_get_preferred_address (mlp, addresses, peer);
 824   aa = paddr->address;
 825   aa->assigned_bw_out = GNUNET_BANDWIDTH_value_init(paddr->bandwidth_out);
 826   /* FIXME use bw in value */
 827   paddr->bandwidth_in = paddr->bandwidth_out;
 828   aa->assigned_bw_in = GNUNET_BANDWIDTH_value_init (paddr->bandwidth_in);
 829   GNUNET_free (paddr);
 830 #endif
 831
 832   if (aa == NULL)
 833   {
 834     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
 835                 "Cannot suggest address for peer `%s'\n", GNUNET_i2s (peer));
 836     return;
 837   }
 838   if (aa->active == GNUNET_NO)
 839   {
 840     aa->active = GNUNET_YES;
 841     active_addr_count++;
 842
 843     send_bw_notification (aa);
 844   }
 845   else
 846   {
 847     /* just to be sure... */
 848     GAS_scheduling_transmit_address_suggestion (peer, aa->plugin, aa->addr,
 849                                                 aa->addr_len, aa->session_id,
 850                                                 aa->ats, aa->ats_count,
 851                                                 aa->assigned_bw_out,
 852                                                 aa->assigned_bw_in);
 853   }
 854
 855 }
 856
 857
 858 static void
 859 request_address_simple (const struct GNUNET_PeerIdentity *peer)
 860 {
 861   struct ATS_Address *aa;
 862   aa = NULL;
 863
 864   /* Get address with: stick to current address, lower distance, lower latency */
 865   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey,
 866                                               &find_address_it, &aa);
 867   if (aa == NULL)
 868   {
 869     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
 870                 "Cannot suggest address for peer `%s'\n", GNUNET_i2s (peer));
 871     return;
 872   }
 873
 874   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
 875               "Suggesting address %p for peer `%s'\n", aa, GNUNET_i2s (peer));
 876
 877   if (aa->active == GNUNET_NO)
 878   {
 879     aa->active = GNUNET_YES;
 880     active_addr_count++;
 881     if (ats_mode == MODE_SIMPLISTIC)
 882     {
 883       recalculate_assigned_bw ();
 884     }
 885   }
 886   else
 887   {
 888     /* just to be sure... */
 889     GAS_scheduling_transmit_address_suggestion (peer, aa->plugin, aa->addr,
 890                                                 aa->addr_len, aa->session_id,
 891                                                 aa->ats, aa->ats_count,
 892                                                 aa->assigned_bw_out,
 893                                                 aa->assigned_bw_in);
 894   }
 895 }
 896
 897
 898 void
 899 GAS_addresses_request_address (const struct GNUNET_PeerIdentity *peer)
 900 {
 901   if (GNUNET_NO == running)
 902     return;
 903
 904   if (ats_mode == MODE_SIMPLISTIC)
 905   {
 906     request_address_simple (peer);
 907   }
 908   if (ats_mode == MODE_MLP)
 909   {
 910     request_address_mlp(peer);
 911   }
 912 }
 913
 914
 915 static int
 916 reset_address_it (void *cls, const struct GNUNET_HashCode * key, void *value)
 917 {
 918   struct ATS_Address *aa = value;
 919
 920   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 921               "Resetting interval for peer `%s' address %p from %llu to 0\n", GNUNET_i2s (&aa->peer), aa, aa->block_interval);
 922
 923   aa->blocked_until = GNUNET_TIME_UNIT_ZERO_ABS;
 924   aa->block_interval = GNUNET_TIME_UNIT_ZERO;
 925   return GNUNET_OK;
 926 }
 927
 928
 929 void
 930 GAS_addresses_handle_backoff_reset (const struct GNUNET_PeerIdentity *peer)
 931 {
 932   GNUNET_break (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_get_multiple (addresses,
 933                                               &peer->hashPubKey,
 934                                               &reset_address_it,
 935                                               NULL));
 936 }
 937
 938
 939
 940 // FIXME: this function should likely end up in the LP-subsystem and
 941 // not with 'addresses' in the future...
 942 void
 943 GAS_addresses_change_preference (const struct GNUNET_PeerIdentity *peer,
 944                                  enum GNUNET_ATS_PreferenceKind kind,
 945                                  float score)
 946 {
 947   if (GNUNET_NO == running)
 948     return;
 949 #if HAVE_LIBGLPK
 950   if (ats_mode == MODE_MLP)
 951     GAS_mlp_address_change_preference (solver, peer, kind, score);
 952 #endif
 953 }
 954
 955
 956
 957 /**
 958  * Initialize address subsystem.
 959  *
 960  * @param cfg configuration to use
 961  * @param stats the statistics handle to use
 962  */
 963 void
 964 GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
 965                     const struct GNUNET_STATISTICS_Handle *stats)
 966 {
 967   int c;
 968   char *quota_wan_in_str;
 969   char *quota_wan_out_str;
 970   char *mode_str;
 971   running = GNUNET_NO;
 972
 973   /* Initialize the system with configuration values */
 974   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", &quota_wan_in_str))
 975   {
 976     if (0 == strcmp(quota_wan_in_str, "unlimited") ||
 977         (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_in_str, &wan_quota_in)))
 978       wan_quota_in = (UINT32_MAX) /10;
 979
 980     GNUNET_free (quota_wan_in_str);
 981     quota_wan_in_str = NULL;
 982   }
 983   else
 984   {
 985     wan_quota_in = (UINT32_MAX) /10;
 986   }
 987
 988   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_OUT", &quota_wan_out_str))
 989   {
 990     if (0 == strcmp(quota_wan_out_str, "unlimited") ||
 991         (GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_wan_out_str, &wan_quota_out)))
 992       wan_quota_out = (UINT32_MAX) /10;
 993
 994     GNUNET_free (quota_wan_out_str);
 995     quota_wan_out_str = NULL;
 996   }
 997   else
 998   {
 999     wan_quota_out = (UINT32_MAX) /10;
1000   }
1001
1002   /* Initialize the addresses database */
1003   addresses = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
1004   GNUNET_assert (NULL != addresses);
1005
1006   /* Figure out configured solution method */
1007   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (cfg, "ats", "MODE", &mode_str))
1008   {
1009       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "No ressource assignment method configured, using simplistic approch\n");
1010       ats_mode = MODE_SIMPLISTIC;
1011   }
1012   else
1013   {
1014       for (c = 0; c < strlen (mode_str); c++)
1015         mode_str[c] = toupper (mode_str[c]);
1016       if (0 == strcmp (mode_str, "SIMPLISTIC"))
1017       {
1018           ats_mode = MODE_SIMPLISTIC;
1019       }
1020       else if (0 == strcmp (mode_str, "MLP"))
1021       {
1022           ats_mode = MODE_MLP;
1023 #if !HAVE_LIBGLPK
1024           GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Assignment method `%s' configured, but GLPK is not availabe, please install \n", mode_str);
1025           ats_mode = MODE_SIMPLISTIC;
1026 #endif
1027       }
1028       else
1029       {
1030           GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid ressource assignment method `%s' configured, using simplistic approch\n", mode_str);
1031           ats_mode = MODE_SIMPLISTIC;
1032       }
1033   }
1034
1035   /* Start configured solution method */
1036   switch (ats_mode)
1037   {
1038     case MODE_MLP:
1039       /* Init the MLP solver with default values */
1040       solver = GAS_mlp_init (cfg, stats, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
1041       if (NULL != solver)
1042       {
1043           ats_mode = MODE_MLP;
1044           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started in %s mode\n", "MLP");
1045           break;
1046       }
1047       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to initialize MLP solver!\n");
1048     case MODE_SIMPLISTIC:
1049       /* Init the simplistic solver with default values */
1050       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started in %s mode\n", "SIMPLISTIC");
1051       solver = GAS_simplistic_init (cfg, stats);
1052       if (NULL != solver)
1053       {
1054           ats_mode = MODE_SIMPLISTIC;
1055           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS started in %s mode\n", "SIMPLISTIC");
1056           break;
1057       }
1058       else
1059       {
1060         GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to initialize simplistic solver!\n");
1061         return;
1062       }
1063       break;
1064     default:
1065       break;
1066   }
1067   /* up and running */
1068   running = GNUNET_YES;
1069 }
1070
1071
1072 /**
1073  * Free memory of address.
1074  *
1075  * @param cls NULL
1076  * @param key peer identity (unused)
1077  * @param value the 'struct ATS_Address' to free
1078  * @return GNUNET_OK (continue to iterate)
1079  */
1080 static int
1081 free_address_it (void *cls, const struct GNUNET_HashCode * key, void *value)
1082 {
1083   struct ATS_Address *aa = value;
1084
1085   destroy_address (aa);
1086   return GNUNET_OK;
1087 }
1088
1089
1090 void
1091 GAS_addresses_destroy_all ()
1092 {
1093   if (GNUNET_NO == running)
1094     return;
1095
1096   if (addresses != NULL)
1097     GNUNET_CONTAINER_multihashmap_iterate (addresses, &free_address_it, NULL);
1098   GNUNET_assert (active_addr_count == 0);
1099 }
1100
1101
1102 /**
1103  * Shutdown address subsystem.
1104  */
1105 void
1106 GAS_addresses_done ()
1107 {
1108   GAS_addresses_destroy_all ();
1109   running = GNUNET_NO;
1110   GNUNET_CONTAINER_multihashmap_destroy (addresses);
1111   addresses = NULL;
1112
1113   /* Stop configured solution method */
1114   switch (ats_mode)
1115   {
1116     case MODE_MLP:
1117       /* Init the MLP solver with default values */
1118       GAS_mlp_done (solver);
1119       break;
1120     case MODE_SIMPLISTIC:
1121       /* Init the simplistic solver with default values */
1122       GAS_simplistic_done (solver);
1123       break;
1124     default:
1125       break;
1126   }
1127 }
1128
1129 struct PeerIteratorContext
1130 {
1131   GNUNET_ATS_Peer_Iterator it;
1132   void *it_cls;
1133   struct GNUNET_CONTAINER_MultiHashMap *peers_returned;
1134 };
1135
1136 static int
1137 peer_it (void *cls,
1138          const struct GNUNET_HashCode * key,
1139          void *value)
1140 {
1141   struct PeerIteratorContext *ip_ctx = cls;
1142   struct GNUNET_PeerIdentity tmp;
1143
1144   if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(ip_ctx->peers_returned, key))
1145   {
1146       GNUNET_CONTAINER_multihashmap_put(ip_ctx->peers_returned, key, NULL, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
1147       tmp.hashPubKey = (*key);
1148       ip_ctx->it (ip_ctx->it_cls, &tmp);
1149   }
1150
1151   return GNUNET_OK;
1152 }
1153
1154 /**
1155  * Return all peers currently known to ATS
1156  *
1157  * @param p_it the iterator to call for every peer, callbach with id == NULL
1158  *        when done
1159  * @param p_it_cls the closure for the iterator
1160  */
1161 void
1162 GAS_addresses_iterate_peers (GNUNET_ATS_Peer_Iterator p_it, void *p_it_cls)
1163 {
1164   struct PeerIteratorContext ip_ctx;
1165   unsigned int size;
1166
1167   if (NULL == p_it)
1168       return;
1169   GNUNET_assert (NULL != addresses);
1170
1171   size = GNUNET_CONTAINER_multihashmap_size(addresses);
1172   if (0 != size)
1173   {
1174     ip_ctx.it = p_it;
1175     ip_ctx.it_cls = p_it_cls;
1176     ip_ctx.peers_returned = GNUNET_CONTAINER_multihashmap_create (size, GNUNET_NO);
1177     GNUNET_CONTAINER_multihashmap_iterate (addresses, &peer_it, &ip_ctx);
1178     GNUNET_CONTAINER_multihashmap_destroy (ip_ctx.peers_returned);
1179   }
1180   p_it (p_it_cls, NULL);
1181 }
1182
1183 struct PeerInfoIteratorContext
1184 {
1185   GNUNET_ATS_PeerInfo_Iterator it;
1186   void *it_cls;
1187 };
1188
1189
1190 static int
1191 peerinfo_it (void *cls,
1192              const struct GNUNET_HashCode * key,
1193              void *value)
1194 {
1195   struct PeerInfoIteratorContext *pi_ctx = cls;
1196   struct ATS_Address *addr = (struct ATS_Address *)  value;
1197   struct GNUNET_ATS_Information *ats;
1198   uint32_t ats_count;
1199
1200   if (NULL != pi_ctx->it)
1201   {
1202     ats_count = assemble_ats_information (addr, &ats);
1203
1204     pi_ctx->it (pi_ctx->it_cls,
1205                 &addr->peer,
1206                 addr->plugin,
1207                 addr->addr, addr->addr_len,
1208                 addr->active,
1209                 ats, ats_count,
1210                 addr->assigned_bw_out,
1211                 addr->assigned_bw_in);
1212     GNUNET_free (ats);
1213   }
1214   return GNUNET_YES;
1215 }
1216
1217
1218 /**
1219  * Return all peers currently known to ATS
1220  *
1221  * @param peer the respective peer
1222  * @param pi_it the iterator to call for every peer
1223  * @param pi_it_cls the closure for the iterator
1224  */
1225 void
1226 GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer, GNUNET_ATS_PeerInfo_Iterator pi_it, void *pi_it_cls)
1227 {
1228   struct PeerInfoIteratorContext pi_ctx;
1229   struct GNUNET_BANDWIDTH_Value32NBO zero_bw;
1230   GNUNET_assert (NULL != peer);
1231   GNUNET_assert (NULL != addresses);
1232   if (NULL == pi_it)
1233     return; /* does not make sense without callback */
1234
1235   zero_bw = GNUNET_BANDWIDTH_value_init (0);
1236   pi_ctx.it = pi_it;
1237   pi_ctx.it_cls = pi_it_cls;
1238
1239   GNUNET_CONTAINER_multihashmap_get_multiple (addresses, &peer->hashPubKey, &peerinfo_it, &pi_ctx);
1240
1241   if (NULL != pi_it)
1242     pi_it (pi_it_cls, NULL, NULL, NULL, 0, GNUNET_NO, NULL, 0, zero_bw, zero_bw);
1243
1244 }
1245
1246
1247 /* end of gnunet-service-ats_addresses.c */