src/ats/gnunet-service-ats_addresses.c

   1 /*
   2  This file is part of GNUnet.
   3  Copyright (C) 2011-2015 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-service-ats_addresses.h"
  29 #include "gnunet-service-ats_performance.h"
  30 #include "gnunet-service-ats_normalization.h"
  31 #include "gnunet-service-ats_plugins.h"
  32
  33
  34 /**
  35  * NOTE: Do not change this documentation. This documentation is based on
  36  * gnunet.org:/vcs/fsnsg/2014-p2p-ats.git/tech-doku/ats-tech-guide.tex
  37  * use build_txt.sh to generate plaintext output
  38  *
  39  *   1 ATS addresses : ATS address management
  40  *
  41  *    This ATS addresses ("addresses") component manages the addresses known to
  42  *    ATS service and suggests addresses to transport service when it is
  43  *    interested in address suggestion for a peer. ATS addresses also
  44  *    instantiates the bandwidth assignment mechanism (solver), notifies it
  45  *    about changes to addresses and forwards changes to bandwidth assignments
  46  *    to transport, depending if transport is interested in this change.
  47  *
  48  *     1.1 Input data
  49  *
  50  *       1.1.1 Addresses
  51  *
  52  *    Addresses are added by specifying peer ID, plugin, address, address length
  53  *    and session, if available. ATS information can be specified if available.
  54  *
  55  *       1.1.2 Networks
  56  *
  57  *    ATS specifies a fix set of networks an address can belong to. For each
  58  *    network an inbound and outbound quota will be specified. The available
  59  *    networks and addtional helper varaibles are defined in
  60  *    gnunet_ats_service.h. At the moment 5 networks are defined:
  61  *      * GNUNET_ATS_NET_UNSPECIFIED
  62  *      * GNUNET_ATS_NET_LOOPBACK
  63  *      * GNUNET_ATS_NET_LAN
  64  *      * GNUNET_ATS_NET_WAN
  65  *      * GNUNET_ATS_NET_WLAN
  66  *
  67  *    The total number of networks defined is stored in
  68  *    GNUNET_ATS_NetworkTypeCount GNUNET_ATS_NetworkType can be used array
  69  *    initializer for an int array, while GNUNET_ATS_NetworkType is an
  70  *    initializer for a char array containing a string description of all
  71  *    networks
  72  *
  73  *       1.1.3 Quotas
  74  *
  75  *    An inbound and outbound quota for each of the networks mentioned in 1.1.2
  76  *    is loaded from ats configuration during initialization. This quota defines
  77  *    to total amount of inbound and outbound traffic allowed for a specific
  78  *    network. The configuration values used are in section ats:
  79  *      * "NETWORK"_QUOTA_IN = <value>
  80  *      * "NETWORK"_QUOTA_IN = <value>
  81  *
  82  *    You can specify quotas by setting the <value> to a:
  83  *      * unrestricted: unlimited
  84  *      * number of bytes: e.g. 10240
  85  *      * fancy value: e.g. 64 Kib
  86  *
  87  *    unlimited is defined as GNUNET_ATS_MaxBandwidthString and equivalent to
  88  *    the value GNUNET_ATS_MaxBandwidth Important predefined values for quotas
  89  *    are:
  90  *      * GNUNET_ATS_DefaultBandwidth: 65536
  91  *      * GNUNET_ATS_MaxBandwidth: UINT32_MAX
  92  *      * GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT: 1024
  93  *
  94  *    Details of loading quotas and default values will be described on
  95  *
  96  *       1.1.4 Preference values
  97  *
  98  *     1.2 Data structures used
  99  *
 100  *    Addresse uses struct ATS_Address for each address. The structs are stored
 101  *    in a linked list and provides a pointer void *solver_information for the
 102  *    solver to store address specific information. It provides the int values
 103  *    active which is set to GNUNET_YES if the address is select for transport
 104  *    use and used, representing that transport service is actively using this
 105  *    address. Address information are stored in peer, addr, addr_len, plugin.
 106  *
 107  *     1.3 Initialization
 108  *
 109  *    During initialization a hashmap to store addresses is created. The quotas
 110  *    for all networks defined for ATS are loaded from configuration. For each
 111  *    network first the logic will check if the string
 112  *    GNUNET_ATS_MaxBandwidthString is configured, if not it will try to convert
 113  *    the configured value as a fancy size and if this fails it will try to use
 114  *    it as a value_number. If no configuration value is found it will assign
 115  *    GNUNET_ATS_DefaultBandwidth. The most important step is to load the
 116  *    configured solver using configuration "[ats]:MODE". Current solvers are
 117  *    MODE_PROPORTIONAL, MODE_MLP. Interaction is done using a solver API
 118  *
 119  *     1.4 Solver API
 120  *
 121  *    Solver functions:
 122  *      * s_init: init the solver with required information
 123  *      * s_add: add a new address
 124  *      * s_update: update ATS values or session for an address
 125  *      * s_get: get prefered address for a peer
 126  *      * s_del: delete an address
 127  *      * s_pref: change preference value for a peer
 128  *      * s_done: shutdown solver
 129  *
 130  *    Callbacks: addresses provides a bandwidth_changed_cb callback to the
 131  *    solver which is called when bandwidth assigned to peer has changed
 132  *
 133  *     1.5 Shutdown
 134  *
 135  *    During shutdown all addresses are freed and the solver told to shutdown
 136  *
 137  *     1.6 Addresses and sessions
 138  *
 139  *    Addresses consist of the address itself and a numerical session. When a
 140  *    new address without a session is added it has no session, so it gets
 141  *    session 0 assigned. When an address with a session is added and an address
 142  *    object with session 0 is found, this object is updated with the session
 143  *    otherwise a new address object with this session assigned is created.
 144  *
 145  *       1.6.1 Terminology
 146  *
 147  *    Addresses a1,a2 with session s1, s2 are "exact" if:
 148  *    (a1 == a2)&&(s1 == s2)
 149  *    Addresses a1,a2 with session s1, s2 are "equivalent" if:
 150  *    (a1 == a2)&&((s1 == s2)||(s1 == 0)||(s2 == 0)
 151  *
 152  *     1.7 Address management
 153  *
 154  *    Transport service notifies ATS about changes to the addresses known to
 155  *    him.
 156  *
 157  *       1.7.1 Adding an address
 158  *
 159  *    When transport learns a new address it tells ATS and ATS is telling
 160  *    addresses about it using GAS_address_add. If not known to addresses it
 161  *    creates a new address object and calls solver's s_add. ATS information are
 162  *    deserialized and solver is notified about the session and ATS information
 163  *    using s_update.
 164  *
 165  *       1.7.2 Updating an address
 166  *
 167  *    Addresses does an lookup up for the existing address with the given
 168  *    session. If disassembles included ATS information and notifies the solver
 169  *    using s_update about the update.
 170  *
 171  *       1.7.3 Deleting an address
 172  *
 173  *    Addresses does an lookup for the exact address and session and if removes
 174  *    this address. If session != 0 the session is set to 0 and the address is
 175  *    kept. If session == 0, the addresses is removed.
 176  *
 177  *       1.7.4 Requesting an address suggestion
 178  *
 179  *    The address client issues a request address message to be notified about
 180  *    address suggestions for a specific peer. Addresses asks the solver with
 181  *    s_get. If no address is available, it will not send a response, otherwise
 182  *    it will respond with the choosen address.
 183  *
 184  *       1.7.5 Address suggestions
 185  *
 186  *    Addresses will notify the client automatically on any bandwidth_changed_cb
 187  *    by the solver if a address suggestion request is pending. If no address is
 188  *    available it will not respond at all If the client is not interested
 189  *    anymore, it has to cancel the address suggestion request.
 190  *
 191  *       1.7.6 Address lifecycle
 192  *
 193  *      * (add address)
 194  *      * (updated address)
 195  *      * (delete address)
 196  *
 197  *     1.8 Bandwidth assignment
 198  *
 199  *    The addresses are used to perform resource allocation operations. ATS
 200  *    addresses takes care of instantiating the solver configured and notifies
 201  *    the respective solver about address changes and receives changes to the
 202  *    bandwidth assignment from the solver. The current bandwidth assignment is
 203  *    sent to transport. The specific solvers will be described in the specific
 204  *    section.
 205  *
 206  *     1.9 Changing peer preferences
 207  *
 208  *    The bandwidth assigned to a peer can be influenced by setting a preference
 209  *    for a peer. The prefernce will be given to to the solver with s_pref which
 210  *    has to take care of the preference value
 211  */
 212
 213
 214 /**
 215  * A multihashmap to store all addresses
 216  */
 217 struct GNUNET_CONTAINER_MultiPeerMap *GSA_addresses;
 218
 219
 220 /**
 221  * Update statistic on number of addresses.
 222  */
 223 static void
 224 update_addresses_stat ()
 225 {
 226   GNUNET_STATISTICS_set (GSA_stats,
 227                          "# addresses",
 228                          GNUNET_CONTAINER_multipeermap_size (GSA_addresses),
 229                          GNUNET_NO);
 230 }
 231
 232
 233 /**
 234  * Disassemble ATS information and update performance information in address
 235  *
 236  * Updates existing information and adds new information
 237  *
 238  * @param dest destination address
 239  * @param update source ATS information
 240  * @param update_count number of ATS information in @a update
 241  * @param delta_dest ats performance information which were updated
 242  *                              including previous value
 243  * @param delta_count number of ATS information in the @a delta_dest
 244  * @return #GNUNET_YES if address was address updated, GNUNET_NO otherwise
 245  */
 246 static unsigned int
 247 disassemble_ats_information (struct ATS_Address *dest,
 248                              const struct GNUNET_ATS_Information *update,
 249                              uint32_t update_count,
 250                              struct GNUNET_ATS_Information **delta_dest,
 251                              uint32_t *delta_count)
 252 {
 253   int c1;
 254   int c2;
 255   int found;
 256   int change;
 257   struct GNUNET_ATS_Information add_atsi[update_count];
 258   struct GNUNET_ATS_Information delta_atsi[update_count];
 259   struct GNUNET_ATS_Information *tmp_atsi;
 260   uint32_t add_atsi_count;
 261   uint32_t delta_atsi_count;
 262
 263   change = GNUNET_NO;
 264   add_atsi_count = 0;
 265   delta_atsi_count = 0;
 266
 267   if (0 == update_count)
 268     return GNUNET_NO;
 269
 270   if (NULL == dest->atsi)
 271   {
 272     /* Create performance information */
 273     dest->atsi =
 274         GNUNET_malloc (update_count * sizeof (struct GNUNET_ATS_Information));
 275     dest->atsi_count = update_count;
 276     memcpy (dest->atsi,
 277             update,
 278             update_count * sizeof(struct GNUNET_ATS_Information));
 279     *delta_dest =
 280         GNUNET_malloc (update_count * sizeof (struct GNUNET_ATS_Information));
 281     for (c1 = 0; c1 < update_count; c1++)
 282     {
 283       (*delta_dest)[c1].type = update[c1].type;
 284       (*delta_dest)[c1].value = htonl (GNUNET_ATS_VALUE_UNDEFINED);
 285     }
 286     (*delta_count) = update_count;
 287     return GNUNET_YES;
 288   }
 289
 290   for (c1 = 0; c1 < update_count; c1++)
 291   {
 292     /* Update existing performance information */
 293     found = GNUNET_NO;
 294     for (c2 = 0; c2 < dest->atsi_count; c2++)
 295     {
 296       if (update[c1].type == dest->atsi[c2].type)
 297       {
 298         if (update[c1].value != dest->atsi[c2].value)
 299         {
 300           /* Save previous value in delta */
 301           delta_atsi[delta_atsi_count] = dest->atsi[c2];
 302           delta_atsi_count++;
 303           /* Set new value */
 304           dest->atsi[c2].value = update[c1].value;
 305           change = GNUNET_YES;
 306         }
 307         found = GNUNET_YES;
 308         break;
 309       }
 310     }
 311     if (GNUNET_NO == found)
 312     {
 313       add_atsi[add_atsi_count] = update[c1];
 314       add_atsi_count++;
 315       delta_atsi[delta_atsi_count].type = update[c1].type;
 316       delta_atsi[delta_atsi_count].value = htonl (GNUNET_ATS_VALUE_UNDEFINED);
 317       delta_atsi_count++;
 318     }
 319   }
 320
 321   if (add_atsi_count > 0)
 322   {
 323     /* Extend ats performance information */
 324
 325     tmp_atsi = GNUNET_malloc ((dest->atsi_count + add_atsi_count) *
 326         (sizeof (struct GNUNET_ATS_Information)));
 327     memcpy (tmp_atsi, dest->atsi,
 328         dest->atsi_count * sizeof(struct GNUNET_ATS_Information));
 329     memcpy (&tmp_atsi[dest->atsi_count], add_atsi,
 330         add_atsi_count * sizeof(struct GNUNET_ATS_Information));
 331     GNUNET_free (dest->atsi);
 332     dest->atsi = tmp_atsi;
 333     dest->atsi_count = dest->atsi_count + add_atsi_count;
 334     change = GNUNET_YES;
 335   }
 336
 337   if (delta_atsi_count > 0)
 338   {
 339     /* Copy delta */
 340     (*delta_dest) =
 341         GNUNET_malloc (delta_atsi_count * sizeof (struct GNUNET_ATS_Information));
 342     memcpy ((*delta_dest), delta_atsi,
 343         delta_atsi_count * sizeof(struct GNUNET_ATS_Information));
 344     (*delta_count) = delta_atsi_count;
 345   }
 346
 347   return change;
 348 }
 349
 350
 351 /**
 352  * Free the given address
 353  *
 354  * @param addr address to destroy
 355  */
 356 static void
 357 free_address (struct ATS_Address *addr)
 358 {
 359   GNUNET_CONTAINER_multipeermap_remove (GSA_addresses,
 360                                         &addr->peer,
 361                                         addr);
 362   update_addresses_stat ();
 363   GAS_plugin_delete_address (addr);
 364   GAS_performance_notify_all_clients (&addr->peer,
 365                                       addr->plugin,
 366                                       addr->addr,
 367                                       addr->addr_len,
 368                                       GNUNET_NO,
 369                                       NULL, 0,
 370                                       GNUNET_BANDWIDTH_ZERO,
 371                                       GNUNET_BANDWIDTH_ZERO);
 372   GNUNET_free (addr->plugin);
 373   GNUNET_free_non_null (addr->atsi);
 374   GNUNET_free (addr);
 375 }
 376
 377
 378 /**
 379  * Create a ATS_address with the given information
 380  *
 381  * @param peer peer
 382  * @param plugin_name plugin
 383  * @param plugin_addr address
 384  * @param plugin_addr_len address length
 385  * @param local_address_info additional local info for the address
 386  * @param session_id session identifier, can never be 0
 387  * @return the ATS_Address
 388  */
 389 static struct ATS_Address *
 390 create_address (const struct GNUNET_PeerIdentity *peer,
 391                 const char *plugin_name,
 392                 const void *plugin_addr,
 393                 size_t plugin_addr_len,
 394                 uint32_t local_address_info,
 395                 uint32_t session_id)
 396 {
 397   struct ATS_Address *aa;
 398   unsigned int c1;
 399   unsigned int c2;
 400
 401   aa = GNUNET_malloc (sizeof (struct ATS_Address) + plugin_addr_len);
 402   aa->peer = *peer;
 403   aa->addr_len = plugin_addr_len;
 404   aa->addr = &aa[1];
 405   memcpy (&aa[1],
 406           plugin_addr,
 407           plugin_addr_len);
 408   aa->plugin = GNUNET_strdup (plugin_name);
 409   aa->session_id = session_id;
 410   aa->local_address_info = local_address_info;
 411
 412   for (c1 = 0; c1 < GNUNET_ATS_QualityPropertiesCount; c1++)
 413   {
 414     aa->atsin[c1].avg_queue_index = 0;
 415     aa->atsin[c1].norm = DEFAULT_REL_QUALITY;
 416     for (c2 = 0; c2 < GAS_normalization_queue_length; c2++)
 417       aa->atsin[c1].atsi_abs[c2] = GNUNET_ATS_VALUE_UNDEFINED;
 418   }
 419   return aa;
 420 }
 421
 422
 423 /**
 424  * Closure for #find_address_cb()
 425  */
 426 struct FindAddressContext
 427 {
 428   /**
 429    * Session Id to look for.
 430    */
 431   uint32_t session_id;
 432
 433   /**
 434    * Where to store matching address result.
 435    */
 436   struct ATS_Address *exact_address;
 437
 438 };
 439
 440
 441 /**
 442  * Find session matching given session ID.
 443  *
 444  * @param cls a `struct FindAddressContext`
 445  * @param key peer id
 446  * @param value the address to compare with
 447  * @return #GNUNET_YES to continue, #GNUNET_NO if address is found
 448  */
 449 static int
 450 find_address_cb (void *cls,
 451                  const struct GNUNET_PeerIdentity *key,
 452                  void *value)
 453 {
 454   struct FindAddressContext *fac = cls;
 455   struct ATS_Address *aa = value;
 456
 457   if (aa->session_id == fac->session_id)
 458   {
 459     fac->exact_address = aa;
 460     return GNUNET_NO;
 461   }
 462   return GNUNET_YES;
 463 }
 464
 465
 466 /**
 467  * Find the exact address
 468  *
 469  * @param peer peer
 470  * @param session_id session id, can never be 0
 471  * @return an ATS_address or NULL
 472  */
 473 static struct ATS_Address *
 474 find_exact_address (const struct GNUNET_PeerIdentity *peer,
 475                     uint32_t session_id)
 476 {
 477   struct FindAddressContext fac;
 478
 479   fac.exact_address = NULL;
 480   fac.session_id = session_id;
 481   GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
 482                                               peer,
 483                                               &find_address_cb, &fac);
 484   return fac.exact_address;
 485 }
 486
 487
 488 /**
 489  * Extract an ATS performance info from an address
 490  *
 491  * @param address the address
 492  * @param type the type to extract in HBO
 493  * @return the value in HBO or #GNUNET_ATS_VALUE_UNDEFINED in HBO if value does not exist
 494  */
 495 static int
 496 get_performance_info (struct ATS_Address *address,
 497                       uint32_t type)
 498 {
 499   uint32_t c1;
 500
 501   if ((NULL == address->atsi) || (0 == address->atsi_count))
 502     return GNUNET_ATS_VALUE_UNDEFINED;
 503
 504   for (c1 = 0; c1 < address->atsi_count; c1++)
 505   {
 506     if (ntohl (address->atsi[c1].type) == type)
 507       return ntohl (address->atsi[c1].value);
 508   }
 509   return GNUNET_ATS_VALUE_UNDEFINED;
 510 }
 511
 512
 513 /**
 514  * Add a new address for a peer.
 515  *
 516  * @param peer peer
 517  * @param plugin_name transport plugin name
 518  * @param plugin_addr plugin address
 519  * @param plugin_addr_len length of the plugin address in @a plugin_addr
 520  * @param local_address_info the local address for the address
 521  * @param session_id session id, can be 0
 522  * @param atsi performance information for this address
 523  * @param atsi_count number of performance information contained in @a atsi
 524  */
 525 void
 526 GAS_addresses_add (const struct GNUNET_PeerIdentity *peer,
 527                    const char *plugin_name,
 528                    const void *plugin_addr,
 529                    size_t plugin_addr_len,
 530                    uint32_t local_address_info,
 531                    uint32_t session_id,
 532                    const struct GNUNET_ATS_Information *atsi,
 533                    uint32_t atsi_count)
 534 {
 535   struct ATS_Address *new_address;
 536   struct GNUNET_ATS_Information *atsi_delta;
 537   uint32_t atsi_delta_count;
 538   uint32_t addr_net;
 539
 540   if (NULL != find_exact_address (peer, session_id))
 541   {
 542     GNUNET_break (0);
 543     return;
 544   }
 545   new_address = create_address (peer,
 546                                 plugin_name,
 547                                 plugin_addr,
 548                                 plugin_addr_len,
 549                                 local_address_info,
 550                                 session_id);
 551   atsi_delta = NULL;
 552   disassemble_ats_information (new_address,
 553                                atsi, atsi_count,
 554                                &atsi_delta,
 555                                &atsi_delta_count);
 556   GNUNET_free_non_null (atsi_delta);
 557   addr_net = get_performance_info (new_address, GNUNET_ATS_NETWORK_TYPE);
 558   if (GNUNET_ATS_VALUE_UNDEFINED == addr_net)
 559     addr_net = GNUNET_ATS_NET_UNSPECIFIED;
 560
 561   /* Add a new address */
 562   new_address->t_added = GNUNET_TIME_absolute_get();
 563   new_address->t_last_activity = GNUNET_TIME_absolute_get();
 564   GNUNET_assert(GNUNET_OK ==
 565                 GNUNET_CONTAINER_multipeermap_put (GSA_addresses,
 566                                                    peer,
 567                                                    new_address,
 568                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 569   update_addresses_stat ();
 570   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 571               "Adding new address for peer `%s' slot %u\n",
 572               GNUNET_i2s (peer),
 573               session_id);
 574   /* Tell solver about new address */
 575   GAS_plugin_solver_lock ();
 576   GAS_plugin_new_address (new_address,
 577                           addr_net);
 578   GAS_normalization_update_property (new_address,
 579                                      atsi,
 580                                      atsi_count);
 581   GAS_plugin_solver_unlock ();
 582   /* Notify performance clients about new address */
 583   GAS_performance_notify_all_clients (&new_address->peer,
 584                                       new_address->plugin,
 585                                       new_address->addr,
 586                                       new_address->addr_len,
 587                                       new_address->active,
 588                                       new_address->atsi,
 589                                       new_address->atsi_count,
 590                                       GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_out),
 591                                       GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_in));
 592 }
 593
 594
 595 /**
 596  * Update an address with new performance information for a peer.
 597  *
 598  * @param peer peer
 599  * @param session_id session id, never 0
 600  * @param atsi performance information for this address
 601  * @param atsi_count number of performance information contained in @a atsi
 602  */
 603 void
 604 GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
 605                       uint32_t session_id,
 606                       const struct GNUNET_ATS_Information *atsi,
 607                       uint32_t atsi_count)
 608 {
 609   struct ATS_Address *aa;
 610   struct GNUNET_ATS_Information *atsi_delta;
 611   uint32_t atsi_delta_count;
 612
 613   /* Get existing address */
 614   aa = find_exact_address (peer,
 615                            session_id);
 616   if (NULL == aa)
 617   {
 618     GNUNET_break (0);
 619     return;
 620   }
 621   if (NULL == aa->solver_information)
 622   {
 623     GNUNET_break (0);
 624     return;
 625   }
 626   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 627               "Received ADDRESS_UPDATE for peer `%s' slot %u\n",
 628               GNUNET_i2s (peer),
 629               (unsigned int) session_id);
 630
 631   /* Update address */
 632   aa->t_last_activity = GNUNET_TIME_absolute_get();
 633   atsi_delta = NULL;
 634   atsi_delta_count = 0;
 635   if (GNUNET_YES ==
 636       disassemble_ats_information (aa, atsi,
 637                                    atsi_count,
 638                                    &atsi_delta,
 639                                    &atsi_delta_count))
 640   {
 641     /* Notify performance clients about updated address */
 642     GAS_performance_notify_all_clients (&aa->peer,
 643                                         aa->plugin,
 644                                         aa->addr,
 645                                         aa->addr_len,
 646                                         aa->active,
 647                                         aa->atsi,
 648                                         aa->atsi_count,
 649                                         GNUNET_BANDWIDTH_value_init (aa->assigned_bw_out),
 650                                         GNUNET_BANDWIDTH_value_init (aa->assigned_bw_in));
 651
 652     GAS_normalization_update_property (aa,
 653                                           atsi,
 654                                           atsi_count);
 655   }
 656   GNUNET_free_non_null (atsi_delta);
 657 }
 658
 659
 660 /**
 661  * Remove an address for a peer.
 662  *
 663  * @param peer peer
 664  * @param session_id session id, can never be 0
 665  */
 666 void
 667 GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
 668                        uint32_t session_id)
 669 {
 670   struct ATS_Address *ea;
 671
 672   /* Get existing address */
 673   ea = find_exact_address (peer,
 674                            session_id);
 675   if (NULL == ea)
 676   {
 677     GNUNET_break (0);
 678     return;
 679   }
 680   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 681               "Received ADDRESS_DESTROYED for peer `%s' session %u\n",
 682               GNUNET_i2s (peer),
 683               session_id);
 684   free_address (ea);
 685 }
 686
 687
 688 /**
 689  * Initialize address subsystem. The addresses subsystem manages the addresses
 690  * known and current performance information. It has a solver component
 691  * responsible for the resource allocation. It tells the solver about changes
 692  * and receives updates when the solver changes the resource allocation.
 693  *
 694  * @param server handle to our server
 695  */
 696 void
 697 GAS_addresses_init (struct GNUNET_SERVER_Handle *server)
 698 {
 699   GSA_addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
 700   update_addresses_stat ();
 701 }
 702
 703
 704 /**
 705  * Destroy all addresses iterator
 706  *
 707  * @param cls NULL
 708  * @param key peer identity (unused)
 709  * @param value the 'struct ATS_Address' to free
 710  * @return #GNUNET_OK (continue to iterate)
 711  */
 712 static int
 713 destroy_all_address_it (void *cls,
 714                         const struct GNUNET_PeerIdentity *key,
 715                         void *value)
 716 {
 717   struct ATS_Address *aa = value;
 718
 719   free_address (aa);
 720   return GNUNET_OK;
 721 }
 722
 723
 724 /**
 725  * Remove all addresses
 726  */
 727 void
 728 GAS_addresses_destroy_all ()
 729 {
 730   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 731               "Destroying all addresses\n");
 732   if (0 ==
 733       GNUNET_CONTAINER_multipeermap_size (GSA_addresses))
 734     return;
 735   GAS_plugin_solver_lock ();
 736   GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
 737                                          &destroy_all_address_it,
 738                                          NULL);
 739   GAS_plugin_solver_unlock ();
 740 }
 741
 742
 743 /**
 744  * Shutdown address subsystem.
 745  */
 746 void
 747 GAS_addresses_done ()
 748 {
 749   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 750              "Shutting down addresses\n");
 751   GAS_addresses_destroy_all ();
 752   GNUNET_CONTAINER_multipeermap_destroy (GSA_addresses);
 753   GSA_addresses = NULL;
 754 }
 755
 756
 757 /**
 758  * Closure for #peerinfo_it().
 759  */
 760 struct PeerInfoIteratorContext
 761 {
 762   /**
 763    * Function to call for each address.
 764    */
 765   GNUNET_ATS_PeerInfo_Iterator it;
 766
 767   /**
 768    * Closure for @e it.
 769    */
 770   void *it_cls;
 771 };
 772
 773
 774 /**
 775  * Iterator to iterate over a peer's addresses
 776  *
 777  * @param cls a `struct PeerInfoIteratorContext`
 778  * @param key the peer id
 779  * @param value the `struct ATS_address`
 780  * @return #GNUNET_OK to continue
 781  */
 782 static int
 783 peerinfo_it (void *cls,
 784              const struct GNUNET_PeerIdentity *key,
 785              void *value)
 786 {
 787   struct PeerInfoIteratorContext *pi_ctx = cls;
 788   struct ATS_Address *addr = value;
 789
 790   pi_ctx->it (pi_ctx->it_cls,
 791               &addr->peer,
 792               addr->plugin,
 793               addr->addr,
 794               addr->addr_len,
 795               addr->active,
 796               addr->atsi, addr->atsi_count,
 797               GNUNET_BANDWIDTH_value_init (addr->assigned_bw_out),
 798               GNUNET_BANDWIDTH_value_init (addr->assigned_bw_in));
 799   return GNUNET_OK;
 800 }
 801
 802
 803 /**
 804  * Return information all peers currently known to ATS
 805  *
 806  * @param peer the respective peer, NULL for 'all' peers
 807  * @param pi_it the iterator to call for every peer
 808  * @param pi_it_cls the closure for @a pi_it
 809  */
 810 void
 811 GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer,
 812                              GNUNET_ATS_PeerInfo_Iterator pi_it,
 813                              void *pi_it_cls)
 814 {
 815   struct PeerInfoIteratorContext pi_ctx;
 816
 817   if (NULL == pi_it)
 818   {
 819     /* does not make sense without callback */
 820     GNUNET_break (0);
 821     return;
 822   }
 823   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 824               "Returning information for %s from a total of %u known addresses\n",
 825               (NULL == peer)
 826               ? "all peers"
 827               : GNUNET_i2s (peer),
 828               (unsigned int) GNUNET_CONTAINER_multipeermap_size (GSA_addresses));
 829   pi_ctx.it = pi_it;
 830   pi_ctx.it_cls = pi_it_cls;
 831   if (NULL == peer)
 832     GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
 833                                            &peerinfo_it,
 834                                            &pi_ctx);
 835   else
 836     GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
 837                                                 peer,
 838                                                 &peerinfo_it, &pi_ctx);
 839   pi_it (pi_it_cls,
 840          NULL, NULL, NULL, 0,
 841          GNUNET_NO,
 842          NULL, 0,
 843          GNUNET_BANDWIDTH_ZERO,
 844          GNUNET_BANDWIDTH_ZERO);
 845 }
 846
 847
 848 /**
 849  * Information we need for the callbacks to return a list of addresses
 850  * back to the client.
 851  */
 852 struct AddressIteration
 853 {
 854   /**
 855    * Actual handle to the client.
 856    */
 857   struct GNUNET_SERVER_Client *client;
 858
 859   /**
 860    * Are we sending all addresses, or only those that are active?
 861    */
 862   int all;
 863
 864   /**
 865    * Which ID should be included in the response?
 866    */
 867   uint32_t id;
 868
 869 };
 870
 871
 872 /**
 873  * Send a #GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE with the
 874  * given address details to the client identified in @a ai.
 875  *
 876  * @param ai our address information context (identifies the client)
 877  * @param id the peer id this address is for
 878  * @param plugin_name name of the plugin that supports this address
 879  * @param plugin_addr address
 880  * @param plugin_addr_len length of @a plugin_addr
 881  * @param active #GNUNET_YES if this address is actively used
 882  * @param atsi ats performance information
 883  * @param atsi_count number of ats performance elements in @a atsi
 884  * @param bandwidth_out current outbound bandwidth assigned to address
 885  * @param bandwidth_in current inbound bandwidth assigned to address
 886  */
 887 static void
 888 transmit_req_addr (struct AddressIteration *ai,
 889                    const struct GNUNET_PeerIdentity *id,
 890                    const char *plugin_name,
 891                    const void *plugin_addr,
 892                    size_t plugin_addr_len,
 893                    int active,
 894                    const struct GNUNET_ATS_Information *atsi,
 895                    uint32_t atsi_count,
 896                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 897                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 898
 899 {
 900   struct GNUNET_ATS_Information *atsp;
 901   struct PeerInformationMessage *msg;
 902   char *addrp;
 903   size_t plugin_name_length;
 904   size_t msize;
 905   struct GNUNET_SERVER_NotificationContext *nc;
 906
 907   if (NULL != plugin_name)
 908     plugin_name_length = strlen (plugin_name) + 1;
 909   else
 910     plugin_name_length = 0;
 911   msize = sizeof (struct PeerInformationMessage) +
 912           atsi_count * sizeof (struct GNUNET_ATS_Information) +
 913           plugin_addr_len + plugin_name_length;
 914   char buf[msize] GNUNET_ALIGN;
 915
 916   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
 917   GNUNET_assert (atsi_count <
 918                  GNUNET_SERVER_MAX_MESSAGE_SIZE /
 919                  sizeof (struct GNUNET_ATS_Information));
 920   msg = (struct PeerInformationMessage *) buf;
 921   msg->header.size = htons (msize);
 922   msg->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE);
 923   msg->ats_count = htonl (atsi_count);
 924   msg->id = htonl (ai->id);
 925   if (NULL != id)
 926     msg->peer = *id;
 927   else
 928     memset (&msg->peer, '\0', sizeof (struct GNUNET_PeerIdentity));
 929   msg->address_length = htons (plugin_addr_len);
 930   msg->address_active = ntohl (active);
 931   msg->plugin_name_length = htons (plugin_name_length);
 932   msg->bandwidth_out = bandwidth_out;
 933   msg->bandwidth_in = bandwidth_in;
 934   atsp = (struct GNUNET_ATS_Information *) &msg[1];
 935   memcpy (atsp, atsi, sizeof (struct GNUNET_ATS_Information) * atsi_count);
 936   addrp = (char *) &atsp[atsi_count];
 937   if (NULL != plugin_addr)
 938     memcpy (addrp, plugin_addr, plugin_addr_len);
 939   if (NULL != plugin_name)
 940     strcpy (&addrp[plugin_addr_len], plugin_name);
 941   nc = *GNUNET_SERVER_client_get_user_context (ai->client,
 942                                                struct GNUNET_SERVER_NotificationContext *);
 943   if (NULL == nc)
 944   {
 945     GNUNET_break (0);
 946     return;
 947   }
 948   GNUNET_SERVER_notification_context_unicast (nc,
 949                                               ai->client,
 950                                               &msg->header,
 951                                               GNUNET_NO);
 952 }
 953
 954
 955 /**
 956  * Iterator for #GAS_addresses_get_peer_info(), called with peer-specific
 957  * information to be passed back to the client.
 958  *
 959  * @param cls closure with our `struct AddressIteration *`
 960  * @param id the peer id
 961  * @param plugin_name plugin name
 962  * @param plugin_addr address
 963  * @param plugin_addr_len length of @a plugin_addr
 964  * @param active is address actively used
 965  * @param atsi ats performance information
 966  * @param atsi_count number of ats performance elements in @a atsi
 967  * @param bandwidth_out current outbound bandwidth assigned to address
 968  * @param bandwidth_in current inbound bandwidth assigned to address
 969  */
 970 static void
 971 req_addr_peerinfo_it (void *cls,
 972                       const struct GNUNET_PeerIdentity *id,
 973                       const char *plugin_name,
 974                       const void *plugin_addr,
 975                       size_t plugin_addr_len,
 976                       int active,
 977                       const struct GNUNET_ATS_Information *atsi,
 978                       uint32_t atsi_count,
 979                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 980                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 981 {
 982   struct AddressIteration *ai = cls;
 983
 984   if ( (NULL == id) &&
 985        (NULL == plugin_name) &&
 986        (NULL == plugin_addr) )
 987   {
 988     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 989                 "Address iteration done for one peer\n");
 990     return;
 991   }
 992   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 993               "Callback for %s peer `%s' plugin `%s' BW out %u, BW in %u\n",
 994               (active == GNUNET_YES) ? "ACTIVE" : "INACTIVE",
 995               GNUNET_i2s (id),
 996               plugin_name,
 997               (unsigned int) ntohl (bandwidth_out.value__),
 998               (unsigned int) ntohl (bandwidth_in.value__));
 999   /* Transmit result (either if address is active, or if
1000      client wanted all addresses) */
1001   if ( (GNUNET_YES != ai->all) &&
1002        (GNUNET_YES != active))
1003     return;
1004   transmit_req_addr (ai,
1005                      id,
1006                      plugin_name,
1007                      plugin_addr, plugin_addr_len,
1008                      active,
1009                      atsi,
1010                      atsi_count,
1011                      bandwidth_out,
1012                      bandwidth_in);
1013 }
1014
1015
1016 /**
1017  * Handle 'address list request' messages from clients.
1018  *
1019  * @param cls unused, NULL
1020  * @param client client that sent the request
1021  * @param message the request message
1022  */
1023 void
1024 GAS_handle_request_address_list (void *cls,
1025                                  struct GNUNET_SERVER_Client *client,
1026                                  const struct GNUNET_MessageHeader *message)
1027 {
1028   struct AddressIteration ai;
1029   const struct AddressListRequestMessage *alrm;
1030   struct GNUNET_PeerIdentity allzeros;
1031
1032   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1033               "Received ADDRESSLIST_REQUEST message\n");
1034   alrm = (const struct AddressListRequestMessage *) message;
1035   ai.all = ntohl (alrm->all);
1036   ai.id = ntohl (alrm->id);
1037   ai.client = client;
1038
1039   memset (&allzeros,
1040           '\0',
1041           sizeof (struct GNUNET_PeerIdentity));
1042   if (0 == memcmp (&alrm->peer,
1043                    &allzeros,
1044                    sizeof (struct GNUNET_PeerIdentity)))
1045   {
1046     /* Return addresses for all peers */
1047     GAS_addresses_get_peer_info (NULL,
1048                                  &req_addr_peerinfo_it,
1049                                  &ai);
1050   }
1051   else
1052   {
1053     /* Return addresses for a specific peer */
1054     GAS_addresses_get_peer_info (&alrm->peer,
1055                                  &req_addr_peerinfo_it,
1056                                  &ai);
1057   }
1058   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1059               "Finished handling `%s' message\n",
1060               "ADDRESSLIST_REQUEST");
1061   transmit_req_addr (&ai,
1062                      NULL, NULL, NULL,
1063                      0, GNUNET_NO,
1064                      NULL, 0,
1065                      GNUNET_BANDWIDTH_ZERO,
1066                      GNUNET_BANDWIDTH_ZERO);
1067   GNUNET_SERVER_receive_done (client,
1068                               GNUNET_OK);
1069 }
1070
1071
1072
1073 /* end of gnunet-service-ats_addresses.c */