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_new_address (new_address,
 576                           addr_net,
 577                           atsi,
 578                           atsi_count);
 579   /* Notify performance clients about new address */
 580   GAS_performance_notify_all_clients (&new_address->peer,
 581                                       new_address->plugin,
 582                                       new_address->addr,
 583                                       new_address->addr_len,
 584                                       new_address->active,
 585                                       new_address->atsi,
 586                                       new_address->atsi_count,
 587                                       GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_out),
 588                                       GNUNET_BANDWIDTH_value_init (new_address->assigned_bw_in));
 589 }
 590
 591
 592 /**
 593  * Update an address with new performance information for a peer.
 594  *
 595  * @param peer peer
 596  * @param session_id session id, never 0
 597  * @param atsi performance information for this address
 598  * @param atsi_count number of performance information contained in @a atsi
 599  */
 600 void
 601 GAS_addresses_update (const struct GNUNET_PeerIdentity *peer,
 602                       uint32_t session_id,
 603                       const struct GNUNET_ATS_Information *atsi,
 604                       uint32_t atsi_count)
 605 {
 606   struct ATS_Address *aa;
 607   struct GNUNET_ATS_Information *atsi_delta;
 608   uint32_t atsi_delta_count;
 609
 610   /* Get existing address */
 611   aa = find_exact_address (peer,
 612                            session_id);
 613   if (NULL == aa)
 614   {
 615     GNUNET_break (0);
 616     return;
 617   }
 618   if (NULL == aa->solver_information)
 619   {
 620     GNUNET_break (0);
 621     return;
 622   }
 623   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 624               "Received ADDRESS_UPDATE for peer `%s' slot %u\n",
 625               GNUNET_i2s (peer),
 626               (unsigned int) session_id);
 627
 628   /* Update address */
 629   aa->t_last_activity = GNUNET_TIME_absolute_get();
 630   atsi_delta = NULL;
 631   atsi_delta_count = 0;
 632   if (GNUNET_YES ==
 633       disassemble_ats_information (aa, atsi,
 634                                    atsi_count,
 635                                    &atsi_delta,
 636                                    &atsi_delta_count))
 637   {
 638     /* Notify performance clients about updated address */
 639     GAS_performance_notify_all_clients (&aa->peer,
 640                                         aa->plugin,
 641                                         aa->addr,
 642                                         aa->addr_len,
 643                                         aa->active,
 644                                         aa->atsi,
 645                                         aa->atsi_count,
 646                                         GNUNET_BANDWIDTH_value_init (aa->assigned_bw_out),
 647                                         GNUNET_BANDWIDTH_value_init (aa->assigned_bw_in));
 648
 649     GAS_normalization_update_property (aa,
 650                                           atsi,
 651                                           atsi_count);
 652   }
 653   GNUNET_free_non_null (atsi_delta);
 654 }
 655
 656
 657 /**
 658  * Remove an address for a peer.
 659  *
 660  * @param peer peer
 661  * @param session_id session id, can never be 0
 662  */
 663 void
 664 GAS_addresses_destroy (const struct GNUNET_PeerIdentity *peer,
 665                        uint32_t session_id)
 666 {
 667   struct ATS_Address *ea;
 668
 669   /* Get existing address */
 670   ea = find_exact_address (peer,
 671                            session_id);
 672   if (NULL == ea)
 673   {
 674     GNUNET_break (0);
 675     return;
 676   }
 677   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 678               "Received ADDRESS_DESTROYED for peer `%s' session %u\n",
 679               GNUNET_i2s (peer),
 680               session_id);
 681   free_address (ea);
 682 }
 683
 684
 685 /**
 686  * Initialize address subsystem. The addresses subsystem manages the addresses
 687  * known and current performance information. It has a solver component
 688  * responsible for the resource allocation. It tells the solver about changes
 689  * and receives updates when the solver changes the resource allocation.
 690  *
 691  * @param server handle to our server
 692  */
 693 void
 694 GAS_addresses_init (struct GNUNET_SERVER_Handle *server)
 695 {
 696   GSA_addresses = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
 697   update_addresses_stat ();
 698 }
 699
 700
 701 /**
 702  * Destroy all addresses iterator
 703  *
 704  * @param cls NULL
 705  * @param key peer identity (unused)
 706  * @param value the 'struct ATS_Address' to free
 707  * @return #GNUNET_OK (continue to iterate)
 708  */
 709 static int
 710 destroy_all_address_it (void *cls,
 711                         const struct GNUNET_PeerIdentity *key,
 712                         void *value)
 713 {
 714   struct ATS_Address *aa = value;
 715
 716   free_address (aa);
 717   return GNUNET_OK;
 718 }
 719
 720
 721 /**
 722  * Remove all addresses
 723  */
 724 void
 725 GAS_addresses_destroy_all ()
 726 {
 727   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 728               "Destroying all addresses\n");
 729   if (0 ==
 730       GNUNET_CONTAINER_multipeermap_size (GSA_addresses))
 731     return;
 732   GAS_plugin_solver_lock ();
 733   GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
 734                                          &destroy_all_address_it,
 735                                          NULL);
 736   GAS_plugin_solver_unlock ();
 737 }
 738
 739
 740 /**
 741  * Shutdown address subsystem.
 742  */
 743 void
 744 GAS_addresses_done ()
 745 {
 746   GNUNET_log(GNUNET_ERROR_TYPE_INFO,
 747              "Shutting down addresses\n");
 748   GAS_addresses_destroy_all ();
 749   GNUNET_CONTAINER_multipeermap_destroy (GSA_addresses);
 750   GSA_addresses = NULL;
 751 }
 752
 753
 754 /**
 755  * Closure for #peerinfo_it().
 756  */
 757 struct PeerInfoIteratorContext
 758 {
 759   /**
 760    * Function to call for each address.
 761    */
 762   GNUNET_ATS_PeerInfo_Iterator it;
 763
 764   /**
 765    * Closure for @e it.
 766    */
 767   void *it_cls;
 768 };
 769
 770
 771 /**
 772  * Iterator to iterate over a peer's addresses
 773  *
 774  * @param cls a `struct PeerInfoIteratorContext`
 775  * @param key the peer id
 776  * @param value the `struct ATS_address`
 777  * @return #GNUNET_OK to continue
 778  */
 779 static int
 780 peerinfo_it (void *cls,
 781              const struct GNUNET_PeerIdentity *key,
 782              void *value)
 783 {
 784   struct PeerInfoIteratorContext *pi_ctx = cls;
 785   struct ATS_Address *addr = value;
 786
 787   pi_ctx->it (pi_ctx->it_cls,
 788               &addr->peer,
 789               addr->plugin,
 790               addr->addr,
 791               addr->addr_len,
 792               addr->active,
 793               addr->atsi, addr->atsi_count,
 794               GNUNET_BANDWIDTH_value_init (addr->assigned_bw_out),
 795               GNUNET_BANDWIDTH_value_init (addr->assigned_bw_in));
 796   return GNUNET_OK;
 797 }
 798
 799
 800 /**
 801  * Return information all peers currently known to ATS
 802  *
 803  * @param peer the respective peer, NULL for 'all' peers
 804  * @param pi_it the iterator to call for every peer
 805  * @param pi_it_cls the closure for @a pi_it
 806  */
 807 void
 808 GAS_addresses_get_peer_info (const struct GNUNET_PeerIdentity *peer,
 809                              GNUNET_ATS_PeerInfo_Iterator pi_it,
 810                              void *pi_it_cls)
 811 {
 812   struct PeerInfoIteratorContext pi_ctx;
 813
 814   if (NULL == pi_it)
 815   {
 816     /* does not make sense without callback */
 817     GNUNET_break (0);
 818     return;
 819   }
 820   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 821               "Returning information for %s from a total of %u known addresses\n",
 822               (NULL == peer)
 823               ? "all peers"
 824               : GNUNET_i2s (peer),
 825               (unsigned int) GNUNET_CONTAINER_multipeermap_size (GSA_addresses));
 826   pi_ctx.it = pi_it;
 827   pi_ctx.it_cls = pi_it_cls;
 828   if (NULL == peer)
 829     GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
 830                                            &peerinfo_it,
 831                                            &pi_ctx);
 832   else
 833     GNUNET_CONTAINER_multipeermap_get_multiple (GSA_addresses,
 834                                                 peer,
 835                                                 &peerinfo_it, &pi_ctx);
 836   pi_it (pi_it_cls,
 837          NULL, NULL, NULL, 0,
 838          GNUNET_NO,
 839          NULL, 0,
 840          GNUNET_BANDWIDTH_ZERO,
 841          GNUNET_BANDWIDTH_ZERO);
 842 }
 843
 844
 845 /**
 846  * Information we need for the callbacks to return a list of addresses
 847  * back to the client.
 848  */
 849 struct AddressIteration
 850 {
 851   /**
 852    * Actual handle to the client.
 853    */
 854   struct GNUNET_SERVER_Client *client;
 855
 856   /**
 857    * Are we sending all addresses, or only those that are active?
 858    */
 859   int all;
 860
 861   /**
 862    * Which ID should be included in the response?
 863    */
 864   uint32_t id;
 865
 866 };
 867
 868
 869 /**
 870  * Send a #GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE with the
 871  * given address details to the client identified in @a ai.
 872  *
 873  * @param ai our address information context (identifies the client)
 874  * @param id the peer id this address is for
 875  * @param plugin_name name of the plugin that supports this address
 876  * @param plugin_addr address
 877  * @param plugin_addr_len length of @a plugin_addr
 878  * @param active #GNUNET_YES if this address is actively used
 879  * @param atsi ats performance information
 880  * @param atsi_count number of ats performance elements in @a atsi
 881  * @param bandwidth_out current outbound bandwidth assigned to address
 882  * @param bandwidth_in current inbound bandwidth assigned to address
 883  */
 884 static void
 885 transmit_req_addr (struct AddressIteration *ai,
 886                    const struct GNUNET_PeerIdentity *id,
 887                    const char *plugin_name,
 888                    const void *plugin_addr,
 889                    size_t plugin_addr_len,
 890                    int active,
 891                    const struct GNUNET_ATS_Information *atsi,
 892                    uint32_t atsi_count,
 893                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 894                    struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 895
 896 {
 897   struct GNUNET_ATS_Information *atsp;
 898   struct PeerInformationMessage *msg;
 899   char *addrp;
 900   size_t plugin_name_length;
 901   size_t msize;
 902   struct GNUNET_SERVER_NotificationContext *nc;
 903
 904   if (NULL != plugin_name)
 905     plugin_name_length = strlen (plugin_name) + 1;
 906   else
 907     plugin_name_length = 0;
 908   msize = sizeof (struct PeerInformationMessage) +
 909           atsi_count * sizeof (struct GNUNET_ATS_Information) +
 910           plugin_addr_len + plugin_name_length;
 911   char buf[msize] GNUNET_ALIGN;
 912
 913   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
 914   GNUNET_assert (atsi_count <
 915                  GNUNET_SERVER_MAX_MESSAGE_SIZE /
 916                  sizeof (struct GNUNET_ATS_Information));
 917   msg = (struct PeerInformationMessage *) buf;
 918   msg->header.size = htons (msize);
 919   msg->header.type = htons (GNUNET_MESSAGE_TYPE_ATS_ADDRESSLIST_RESPONSE);
 920   msg->ats_count = htonl (atsi_count);
 921   msg->id = htonl (ai->id);
 922   if (NULL != id)
 923     msg->peer = *id;
 924   else
 925     memset (&msg->peer, '\0', sizeof (struct GNUNET_PeerIdentity));
 926   msg->address_length = htons (plugin_addr_len);
 927   msg->address_active = ntohl (active);
 928   msg->plugin_name_length = htons (plugin_name_length);
 929   msg->bandwidth_out = bandwidth_out;
 930   msg->bandwidth_in = bandwidth_in;
 931   atsp = (struct GNUNET_ATS_Information *) &msg[1];
 932   memcpy (atsp, atsi, sizeof (struct GNUNET_ATS_Information) * atsi_count);
 933   addrp = (char *) &atsp[atsi_count];
 934   if (NULL != plugin_addr)
 935     memcpy (addrp, plugin_addr, plugin_addr_len);
 936   if (NULL != plugin_name)
 937     strcpy (&addrp[plugin_addr_len], plugin_name);
 938   nc = *GNUNET_SERVER_client_get_user_context (ai->client,
 939                                                struct GNUNET_SERVER_NotificationContext *);
 940   if (NULL == nc)
 941   {
 942     GNUNET_break (0);
 943     return;
 944   }
 945   GNUNET_SERVER_notification_context_unicast (nc,
 946                                               ai->client,
 947                                               &msg->header,
 948                                               GNUNET_NO);
 949 }
 950
 951
 952 /**
 953  * Iterator for #GAS_addresses_get_peer_info(), called with peer-specific
 954  * information to be passed back to the client.
 955  *
 956  * @param cls closure with our `struct AddressIteration *`
 957  * @param id the peer id
 958  * @param plugin_name plugin name
 959  * @param plugin_addr address
 960  * @param plugin_addr_len length of @a plugin_addr
 961  * @param active is address actively used
 962  * @param atsi ats performance information
 963  * @param atsi_count number of ats performance elements in @a atsi
 964  * @param bandwidth_out current outbound bandwidth assigned to address
 965  * @param bandwidth_in current inbound bandwidth assigned to address
 966  */
 967 static void
 968 req_addr_peerinfo_it (void *cls,
 969                       const struct GNUNET_PeerIdentity *id,
 970                       const char *plugin_name,
 971                       const void *plugin_addr,
 972                       size_t plugin_addr_len,
 973                       int active,
 974                       const struct GNUNET_ATS_Information *atsi,
 975                       uint32_t atsi_count,
 976                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
 977                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
 978 {
 979   struct AddressIteration *ai = cls;
 980
 981   if ( (NULL == id) &&
 982        (NULL == plugin_name) &&
 983        (NULL == plugin_addr) )
 984   {
 985     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 986                 "Address iteration done for one peer\n");
 987     return;
 988   }
 989   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 990               "Callback for %s peer `%s' plugin `%s' BW out %u, BW in %u\n",
 991               (active == GNUNET_YES) ? "ACTIVE" : "INACTIVE",
 992               GNUNET_i2s (id),
 993               plugin_name,
 994               (unsigned int) ntohl (bandwidth_out.value__),
 995               (unsigned int) ntohl (bandwidth_in.value__));
 996   /* Transmit result (either if address is active, or if
 997      client wanted all addresses) */
 998   if ( (GNUNET_YES != ai->all) &&
 999        (GNUNET_YES != active))
1000     return;
1001   transmit_req_addr (ai,
1002                      id,
1003                      plugin_name,
1004                      plugin_addr, plugin_addr_len,
1005                      active,
1006                      atsi,
1007                      atsi_count,
1008                      bandwidth_out,
1009                      bandwidth_in);
1010 }
1011
1012
1013 /**
1014  * Handle 'address list request' messages from clients.
1015  *
1016  * @param cls unused, NULL
1017  * @param client client that sent the request
1018  * @param message the request message
1019  */
1020 void
1021 GAS_handle_request_address_list (void *cls,
1022                                  struct GNUNET_SERVER_Client *client,
1023                                  const struct GNUNET_MessageHeader *message)
1024 {
1025   struct AddressIteration ai;
1026   const struct AddressListRequestMessage *alrm;
1027   struct GNUNET_PeerIdentity allzeros;
1028
1029   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1030               "Received ADDRESSLIST_REQUEST message\n");
1031   alrm = (const struct AddressListRequestMessage *) message;
1032   ai.all = ntohl (alrm->all);
1033   ai.id = ntohl (alrm->id);
1034   ai.client = client;
1035
1036   memset (&allzeros,
1037           '\0',
1038           sizeof (struct GNUNET_PeerIdentity));
1039   if (0 == memcmp (&alrm->peer,
1040                    &allzeros,
1041                    sizeof (struct GNUNET_PeerIdentity)))
1042   {
1043     /* Return addresses for all peers */
1044     GAS_addresses_get_peer_info (NULL,
1045                                  &req_addr_peerinfo_it,
1046                                  &ai);
1047   }
1048   else
1049   {
1050     /* Return addresses for a specific peer */
1051     GAS_addresses_get_peer_info (&alrm->peer,
1052                                  &req_addr_peerinfo_it,
1053                                  &ai);
1054   }
1055   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1056               "Finished handling `%s' message\n",
1057               "ADDRESSLIST_REQUEST");
1058   transmit_req_addr (&ai,
1059                      NULL, NULL, NULL,
1060                      0, GNUNET_NO,
1061                      NULL, 0,
1062                      GNUNET_BANDWIDTH_ZERO,
1063                      GNUNET_BANDWIDTH_ZERO);
1064   GNUNET_SERVER_receive_done (client,
1065                               GNUNET_OK);
1066 }
1067
1068
1069
1070 /* end of gnunet-service-ats_addresses.c */