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