src/ats/ats_api.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010,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  * @file ats/ats_api.c
  22  * @brief automatic transport selection API
  23  * @author Christian Grothoff
  24  * @author Matthias Wachs
  25  *
  26  * TODO:
  27  * - write test case
  28  * - extend API to get performance data
  29  * - implement simplistic strategy based on say 'lowest latency' or strict ordering
  30  * - extend API to get peer preferences, implement proportional bandwidth assignment
  31  * - re-implement API against a real ATS service (!)
  32  */
  33 #include "platform.h"
  34 #include "gnunet_ats_service.h"
  35
  36 #define DEBUG_ATS GNUNET_NO
  37
  38 // NOTE: this implementation is simply supposed
  39 // to implement a simplistic strategy in-process;
  40 // in the future, we plan to replace it with a real
  41 // service implementation
  42
  43 /**
  44  * Allocation record for a peer's address.
  45  */
  46 struct AllocationRecord
  47 {
  48
  49   /**
  50    * Performance information associated with this address (array).
  51    */
  52   struct GNUNET_TRANSPORT_ATS_Information *ats;
  53
  54   /**
  55    * Name of the plugin
  56    */
  57   char *plugin_name;
  58
  59   /**
  60    * Address this record represents, allocated at the end of this struct.
  61    */
  62   const void *plugin_addr;
  63
  64   /**
  65    * Session associated with this record.
  66    */
  67   struct Session *session;
  68
  69   /**
  70    * Number of bytes in plugin_addr.
  71    */
  72   size_t plugin_addr_len;
  73
  74   /**
  75    * Number of entries in 'ats'.
  76    */
  77   uint32_t ats_count;
  78
  79   /**
  80    * Bandwidth assigned to this address right now, 0 for none.
  81    */
  82   struct GNUNET_BANDWIDTH_Value32NBO bandwidth;
  83
  84   /**
  85    * Set to GNUNET_YES if this is the connected address of a connected peer.
  86    */
  87   int connected;
  88
  89 };
  90
  91
  92 /**
  93  * Opaque handle to obtain address suggestions.
  94  */
  95 struct GNUNET_ATS_SuggestionContext
  96 {
  97
  98   /**
  99    * Function to call with our final suggestion.
 100    */
 101   GNUNET_ATS_AddressSuggestionCallback cb;
 102
 103   /**
 104    * Closure for 'cb'.
 105    */
 106   void *cb_cls;
 107
 108   /**
 109    * Global ATS handle.
 110    */
 111   struct GNUNET_ATS_Handle *atc;
 112
 113   /**
 114    * Which peer are we monitoring?
 115    */
 116   struct GNUNET_PeerIdentity target;
 117
 118 };
 119
 120
 121 /**
 122  * Handle to the ATS subsystem.
 123  */
 124 struct GNUNET_ATS_Handle
 125 {
 126   /**
 127    * Configuration.
 128    */
 129   const struct GNUNET_CONFIGURATION_Handle *cfg;
 130
 131   /**
 132    * Function to call when the allocation changes.
 133    */
 134   GNUNET_TRANSPORT_ATS_AllocationNotification alloc_cb;
 135
 136   /**
 137    * Closure for 'alloc_cb'.
 138    */
 139   void *alloc_cb_cls;
 140
 141   /**
 142    * Information about all connected peers.  Maps peer identities
 143    * to one or more 'struct AllocationRecord' values.
 144    */
 145   struct GNUNET_CONTAINER_MultiHashMap *peers;
 146
 147   /**
 148    * Map of PeerIdentities to 'struct GNUNET_ATS_SuggestionContext's.
 149    */
 150   struct GNUNET_CONTAINER_MultiHashMap *notify_map;
 151
 152
 153   /**
 154    * Task scheduled to update our bandwidth assignment.
 155    */
 156   GNUNET_SCHEDULER_TaskIdentifier ba_task;
 157
 158   /**
 159    * Total bandwidth per configuration.
 160    */
 161   unsigned long long total_bps;
 162 };
 163
 164
 165 /**
 166  * Count number of connected records.
 167  *
 168  * @param cls pointer to counter
 169  * @param key identity of the peer associated with the records
 170  * @param value a 'struct AllocationRecord'
 171  * @return GNUNET_YES (continue iteration)
 172  */
 173 static int
 174 count_connections (void *cls, const GNUNET_HashCode * key, void *value)
 175 {
 176   unsigned int *ac = cls;
 177   struct AllocationRecord *ar = value;
 178
 179   if (GNUNET_YES == ar->connected)
 180     (*ac)++;
 181   return GNUNET_YES;
 182 }
 183
 184
 185 /**
 186  * Closure for 'set_bw_connections'.
 187  */
 188 struct SetBandwidthContext
 189 {
 190   /**
 191    * ATS handle.
 192    */
 193   struct GNUNET_ATS_Handle *atc;
 194
 195   /**
 196    * Bandwidth to assign.
 197    */
 198   struct GNUNET_BANDWIDTH_Value32NBO bw;
 199 };
 200
 201
 202 /**
 203  * Set bandwidth based on record.
 204  *
 205  * @param cls 'struct SetBandwidthContext'
 206  * @param key identity of the peer associated with the records
 207  * @param value a 'struct AllocationRecord'
 208  * @return GNUNET_YES (continue iteration)
 209  */
 210 static int
 211 set_bw_connections (void *cls, const GNUNET_HashCode * key, void *value)
 212 {
 213   struct SetBandwidthContext *sbc = cls;
 214   struct AllocationRecord *ar = value;
 215
 216   if (GNUNET_YES == ar->connected)
 217   {
 218     ar->bandwidth = sbc->bw;
 219     sbc->atc->alloc_cb (sbc->atc->alloc_cb_cls,
 220                         (const struct GNUNET_PeerIdentity *) key,
 221                         ar->plugin_name, ar->session, ar->plugin_addr,
 222                         ar->plugin_addr_len, ar->bandwidth);
 223   }
 224   else if (ntohl (ar->bandwidth.value__) > 0)
 225   {
 226     ar->bandwidth = GNUNET_BANDWIDTH_value_init (0);
 227     sbc->atc->alloc_cb (sbc->atc->alloc_cb_cls,
 228                         (const struct GNUNET_PeerIdentity *) key,
 229                         ar->plugin_name, ar->session, ar->plugin_addr,
 230                         ar->plugin_addr_len, ar->bandwidth);
 231   }
 232   return GNUNET_YES;
 233 }
 234
 235
 236 /**
 237  * Task run to update bandwidth assignments.
 238  *
 239  * @param cls the 'struct GNUNET_ATS_Handle'
 240  * @param tc scheduler context
 241  */
 242 static void
 243 update_bandwidth_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 244 {
 245   struct GNUNET_ATS_Handle *atc = cls;
 246   unsigned int ac = 0;
 247   struct SetBandwidthContext bwc;
 248
 249   atc->ba_task = GNUNET_SCHEDULER_NO_TASK;
 250   /* FIXME: update calculations NICELY; what follows is a naive version */
 251   GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &count_connections, &ac);
 252   bwc.atc = atc;
 253   if (ac == 0)
 254     ac++;
 255   GNUNET_assert (ac > 0);
 256   bwc.bw = GNUNET_BANDWIDTH_value_init (atc->total_bps / ac);
 257   GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &set_bw_connections, &bwc);
 258 }
 259
 260
 261 /**
 262  * Calculate an updated bandwidth assignment and notify.
 263  *
 264  * @param atc handle
 265  * @param change which allocation record changed?
 266  */
 267 static void
 268 update_bandwidth_assignment (struct GNUNET_ATS_Handle *atc,
 269                              struct AllocationRecord *change)
 270 {
 271   /* FIXME: based on the 'change', update the LP-problem... */
 272   if (atc->ba_task == GNUNET_SCHEDULER_NO_TASK)
 273     atc->ba_task = GNUNET_SCHEDULER_add_now (&update_bandwidth_task, atc);
 274 }
 275
 276
 277 /**
 278  * Function called with feasbile addresses we might want to suggest.
 279  *
 280  * @param cls the 'struct GNUNET_ATS_SuggestionContext'
 281  * @param key identity of the peer
 282  * @param value a 'struct AllocationRecord' for the peer
 283  * @return GNUNET_NO if we're done, GNUNET_YES if we did not suggest an address yet
 284  */
 285 static int
 286 suggest_address (void *cls, const GNUNET_HashCode * key, void *value)
 287 {
 288   struct GNUNET_ATS_SuggestionContext *asc = cls;
 289   struct AllocationRecord *ar = value;
 290
 291 #if DEBUG_ATS
 292   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api",
 293                    "Suggesting address for peer `%s'\n", GNUNET_h2s (key));
 294 #endif
 295
 296   /* trivial strategy: pick first available address... */
 297   asc->cb (asc->cb_cls, &asc->target, ar->plugin_name, ar->plugin_addr,
 298            ar->plugin_addr_len, ar->session,
 299            GNUNET_BANDWIDTH_value_init (asc->atc->total_bps / 32), ar->ats,
 300            ar->ats_count);
 301   asc->cb = NULL;
 302   return GNUNET_NO;
 303 }
 304
 305 int
 306 map_it (void *cls, const GNUNET_HashCode * key, void *value)
 307 {
 308   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api", "Found entry for %s\n",
 309                    GNUNET_h2s (key));
 310   return GNUNET_YES;
 311 }
 312
 313 /**
 314  * We would like to establish a new connection with a peer.
 315  * ATS should suggest a good address to begin with.
 316  *
 317  * @param atc handle
 318  * @param peer identity of the new peer
 319  * @param cb function to call with the address
 320  * @param cb_cls closure for cb
 321  */
 322 struct GNUNET_ATS_SuggestionContext *
 323 GNUNET_ATS_suggest_address (struct GNUNET_ATS_Handle *atc,
 324                             const struct GNUNET_PeerIdentity *peer,
 325                             GNUNET_ATS_AddressSuggestionCallback cb,
 326                             void *cb_cls)
 327 {
 328   struct GNUNET_ATS_SuggestionContext *asc;
 329
 330 #if DEBUG_ATS
 331   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api",
 332                    "Looking up suggested address for peer `%s'\n",
 333                    GNUNET_i2s (peer));
 334 #endif
 335   int count = 0;
 336
 337   asc = GNUNET_malloc (sizeof (struct GNUNET_ATS_SuggestionContext));
 338   asc->cb = cb;
 339   asc->cb_cls = cb_cls;
 340   asc->atc = atc;
 341   asc->target = *peer;
 342   count =
 343       GNUNET_CONTAINER_multihashmap_get_multiple (atc->peers, &peer->hashPubKey,
 344                                                   &suggest_address, asc);
 345
 346   if (NULL == asc->cb)
 347   {
 348     GNUNET_free (asc);
 349     return NULL;
 350   }
 351   GNUNET_CONTAINER_multihashmap_put (atc->notify_map, &peer->hashPubKey, asc,
 352                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 353   return asc;
 354 }
 355
 356
 357 /**
 358  * Cancel suggestion request.
 359  *
 360  * @param asc handle of the request to cancel
 361  */
 362 void
 363 GNUNET_ATS_suggest_address_cancel (struct GNUNET_ATS_SuggestionContext *asc)
 364 {
 365   GNUNET_assert (GNUNET_OK ==
 366                  GNUNET_CONTAINER_multihashmap_remove (asc->atc->notify_map,
 367                                                        &asc->target.hashPubKey,
 368                                                        asc));
 369   GNUNET_free (asc);
 370 }
 371
 372
 373 /**
 374  * Initialize the ATS subsystem.
 375  *
 376  * @param cfg configuration to use
 377  * @param alloc_cb notification to call whenever the allocation changed
 378  * @param alloc_cb_cls closure for 'alloc_cb'
 379  * @return ats context
 380  */
 381 struct GNUNET_ATS_Handle *
 382 GNUNET_ATS_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
 383                  GNUNET_TRANSPORT_ATS_AllocationNotification alloc_cb,
 384                  void *alloc_cb_cls)
 385 {
 386   struct GNUNET_ATS_Handle *atc;
 387
 388 #if DEBUG_ATS
 389   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api", "ATS init\n");
 390 #endif
 391   atc = GNUNET_malloc (sizeof (struct GNUNET_ATS_Handle));
 392   atc->cfg = cfg;
 393   atc->alloc_cb = alloc_cb;
 394   atc->alloc_cb_cls = alloc_cb_cls;
 395   atc->peers = GNUNET_CONTAINER_multihashmap_create (256);
 396   atc->notify_map = GNUNET_CONTAINER_multihashmap_create (256);
 397   GNUNET_CONFIGURATION_get_value_number (cfg, "core", "TOTAL_QUOTA_OUT",
 398                                          &atc->total_bps);
 399   return atc;
 400 }
 401
 402
 403 /**
 404  * Free an allocation record.
 405  *
 406  * @param cls unused
 407  * @param key identity of the peer associated with the record
 408  * @param value the 'struct AllocationRecord' to free
 409  * @return GNUNET_OK (continue to iterate)
 410  */
 411 static int
 412 destroy_allocation_record (void *cls, const GNUNET_HashCode * key, void *value)
 413 {
 414   struct AllocationRecord *ar = value;
 415
 416   GNUNET_array_grow (ar->ats, ar->ats_count, 0);
 417   GNUNET_free (ar->plugin_name);
 418   GNUNET_free (ar);
 419   return GNUNET_OK;
 420 }
 421
 422
 423 /**
 424  * Shutdown the ATS subsystem.
 425  *
 426  * @param atc handle
 427  */
 428 void
 429 GNUNET_ATS_shutdown (struct GNUNET_ATS_Handle *atc)
 430 {
 431 #if DEBUG_ATS
 432   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api", "ATS shutdown\n");
 433 #endif
 434   if (GNUNET_SCHEDULER_NO_TASK != atc->ba_task)
 435   {
 436     GNUNET_SCHEDULER_cancel (atc->ba_task);
 437     atc->ba_task = GNUNET_SCHEDULER_NO_TASK;
 438   }
 439   GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &destroy_allocation_record,
 440                                          NULL);
 441   GNUNET_CONTAINER_multihashmap_destroy (atc->peers);
 442   GNUNET_assert (GNUNET_CONTAINER_multihashmap_size (atc->notify_map) == 0);
 443   GNUNET_CONTAINER_multihashmap_destroy (atc->notify_map);
 444   atc->notify_map = NULL;
 445   GNUNET_free (atc);
 446 }
 447
 448
 449 /**
 450  * Closure for 'update_session'
 451  */
 452 struct UpdateSessionContext
 453 {
 454   /**
 455    * Ats handle.
 456    */
 457   struct GNUNET_ATS_Handle *atc;
 458
 459   /**
 460    * Allocation record with new information.
 461    */
 462   struct AllocationRecord *arnew;
 463 };
 464
 465
 466 /**
 467  * Update an allocation record, merging with the new information
 468  *
 469  * @param cls a new 'struct AllocationRecord'
 470  * @param key identity of the peer associated with the records
 471  * @param value the old 'struct AllocationRecord'
 472  * @return GNUNET_YES if the records do not match,
 473  *         GNUNET_NO if the record do match and 'old' was updated
 474  */
 475 static int
 476 update_session (void *cls, const GNUNET_HashCode * key, void *value)
 477 {
 478   struct UpdateSessionContext *usc = cls;
 479   struct AllocationRecord *arnew = usc->arnew;
 480   struct AllocationRecord *arold = value;
 481   int change;
 482   int c_old;
 483   int c_new;
 484   int found;
 485
 486
 487 #if DEBUG_ATS
 488   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api",
 489                    "Updating session for peer `%s' plugin `%s'\n",
 490                    GNUNET_h2s (key), arold->plugin_name);
 491 #endif
 492
 493   if (0 != strcmp (arnew->plugin_name, arold->plugin_name))
 494     return GNUNET_YES;
 495   if (((arnew->session == arold->session) && (arnew->session != NULL)) ||
 496       ((arold->session == NULL) &&
 497        (arold->plugin_addr_len == arnew->plugin_addr_len) &&
 498        (0 ==
 499         memcmp (arold->plugin_addr, arnew->plugin_addr,
 500                 arnew->plugin_addr_len))))
 501   {
 502     change = GNUNET_NO;
 503     /* records match */
 504     if (arnew->session != arold->session)
 505     {
 506       arold->session = arnew->session;
 507       change = GNUNET_YES;
 508     }
 509     if ((arnew->connected == GNUNET_YES) && (arold->connected == GNUNET_NO))
 510     {
 511       arold->connected = GNUNET_YES;
 512       change = GNUNET_YES;
 513     }
 514
 515     /* Update existing value */
 516     c_new = 0;
 517     while (c_new < arnew->ats_count)
 518     {
 519       c_old = 0;
 520       found = GNUNET_NO;
 521       while (c_old < arold->ats_count)
 522       {
 523         if (arold->ats[c_old].type == arnew->ats[c_new].type)
 524         {
 525 #if DEBUG_ATS
 526           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 527                       "Found type %i, old value=%i new value=%i\n",
 528                       ntohl (arold->ats[c_old].type),
 529                       ntohl (arold->ats[c_old].value),
 530                       ntohl (arnew->ats[c_new].value));
 531 #endif
 532           arold->ats[c_old].value = arnew->ats[c_new].value;
 533           found = GNUNET_YES;
 534         }
 535         c_old++;
 536       }
 537       /* Add new value */
 538       if (found == GNUNET_NO)
 539       {
 540 #if DEBUG_ATS
 541         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added new type %i new value=%i\n",
 542                     ntohl (arnew->ats[c_new].type),
 543                     ntohl (arnew->ats[c_new].value));
 544         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Old array size: %u\n",
 545                     arold->ats_count);
 546 #endif
 547         GNUNET_array_grow (arold->ats, arold->ats_count, arold->ats_count + 1);
 548         GNUNET_assert (arold->ats_count >= 2);
 549         arold->ats[arold->ats_count - 2].type = arnew->ats[c_new].type;
 550         arold->ats[arold->ats_count - 2].value = arnew->ats[c_new].value;
 551         arold->ats[arold->ats_count - 1].type = htonl (0);
 552         arold->ats[arold->ats_count - 1].value = htonl (0);
 553 #if DEBUG_ATS
 554         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New array size: %i\n",
 555                     arold->ats_count);
 556 #endif
 557       }
 558       c_new++;
 559     }
 560
 561     if (GNUNET_YES == change)
 562       update_bandwidth_assignment (usc->atc, arold);
 563     return GNUNET_NO;
 564   }
 565   return GNUNET_YES;
 566 }
 567
 568
 569 /**
 570  * Create an allocation record with the given properties.
 571  *
 572  * @param plugin_name name of the currently used transport plugin
 573  * @param session session in use (if available)
 574  * @param plugin_addr address in use (if available)
 575  * @param plugin_addr_len number of bytes in plugin_addr
 576  * @param ats performance data for the connection
 577  * @param ats_count number of performance records in 'ats'
 578  */
 579 static struct AllocationRecord *
 580 create_allocation_record (const char *plugin_name, struct Session *session,
 581                           const void *plugin_addr, size_t plugin_addr_len,
 582                           const struct GNUNET_TRANSPORT_ATS_Information *ats,
 583                           uint32_t ats_count)
 584 {
 585   struct AllocationRecord *ar;
 586
 587   ar = GNUNET_malloc (sizeof (struct AllocationRecord) + plugin_addr_len);
 588   ar->plugin_name = GNUNET_strdup (plugin_name);
 589   ar->plugin_addr = &ar[1];
 590   memcpy (&ar[1], plugin_addr, plugin_addr_len);
 591   ar->session = session;
 592   ar->plugin_addr_len = plugin_addr_len;
 593   GNUNET_assert (ats_count > 0);
 594   GNUNET_array_grow (ar->ats, ar->ats_count, ats_count);
 595   memcpy (ar->ats, ats,
 596           ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
 597   return ar;
 598 }
 599
 600
 601 /**
 602  * Mark all matching allocation records as not connected.
 603  *
 604  * @param cls 'struct GTS_AtsHandle'
 605  * @param key identity of the peer associated with the record
 606  * @param value the 'struct AllocationRecord' to clear the 'connected' flag
 607  * @return GNUNET_OK (continue to iterate)
 608  */
 609 static int
 610 disconnect_peer (void *cls, const GNUNET_HashCode * key, void *value)
 611 {
 612   struct GNUNET_ATS_Handle *atc = cls;
 613   struct AllocationRecord *ar = value;
 614
 615   if (GNUNET_YES == ar->connected)
 616   {
 617     ar->connected = GNUNET_NO;
 618     update_bandwidth_assignment (atc, ar);
 619   }
 620   return GNUNET_OK;
 621 }
 622
 623
 624 /**
 625  * We established a new connection with a peer (for example, because
 626  * core asked for it or because the other peer connected to us).
 627  * Calculate bandwidth assignments including the new peer.
 628  *
 629  * @param atc handle
 630  * @param peer identity of the new peer
 631  * @param plugin_name name of the currently used transport plugin
 632  * @param session session in use (if available)
 633  * @param plugin_addr address in use (if available)
 634  * @param plugin_addr_len number of bytes in plugin_addr
 635  * @param ats performance data for the connection
 636  * @param ats_count number of performance records in 'ats'
 637  */
 638 void
 639 GNUNET_ATS_peer_connect (struct GNUNET_ATS_Handle *atc,
 640                          const struct GNUNET_PeerIdentity *peer,
 641                          const char *plugin_name, struct Session *session,
 642                          const void *plugin_addr, size_t plugin_addr_len,
 643                          const struct GNUNET_TRANSPORT_ATS_Information *ats,
 644                          uint32_t ats_count)
 645 {
 646   struct AllocationRecord *ar;
 647   struct UpdateSessionContext usc;
 648
 649   (void) GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &disconnect_peer,
 650                                                 atc);
 651   ar = create_allocation_record (plugin_name, session, plugin_addr,
 652                                  plugin_addr_len, ats, ats_count);
 653   ar->connected = GNUNET_YES;
 654   usc.atc = atc;
 655   usc.arnew = ar;
 656   if (GNUNET_SYSERR ==
 657       GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &update_session, &usc))
 658   {
 659     destroy_allocation_record (NULL, &peer->hashPubKey, ar);
 660     return;
 661   }
 662   GNUNET_assert (GNUNET_OK ==
 663                  GNUNET_CONTAINER_multihashmap_put (atc->peers,
 664                                                     &peer->hashPubKey, ar,
 665                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 666 }
 667
 668
 669 /**
 670  * We disconnected from the given peer (for example, because ats, core
 671  * or blacklist asked for it or because the other peer disconnected).
 672  * Calculate bandwidth assignments without the peer.
 673  *
 674  * @param atc handle
 675  * @param peer identity of the new peer
 676  */
 677 void
 678 GNUNET_ATS_peer_disconnect (struct GNUNET_ATS_Handle *atc,
 679                             const struct GNUNET_PeerIdentity *peer)
 680 {
 681   (void) GNUNET_CONTAINER_multihashmap_get_multiple (atc->peers,
 682                                                      &peer->hashPubKey,
 683                                                      &disconnect_peer, atc);
 684 }
 685
 686
 687 /**
 688  * Closure for 'destroy_allocation_record'
 689  */
 690 struct SessionDestroyContext
 691 {
 692   /**
 693    * Ats handle.
 694    */
 695   struct GNUNET_ATS_Handle *atc;
 696
 697   /**
 698    * Session being destroyed.
 699    */
 700   const struct Session *session;
 701 };
 702
 703
 704 /**
 705  * Free an allocation record matching the given session.
 706  *
 707  * @param cls the 'struct SessionDestroyContext'
 708  * @param key identity of the peer associated with the record
 709  * @param value the 'struct AllocationRecord' to free
 710  * @return GNUNET_OK (continue to iterate)
 711  */
 712 static int
 713 destroy_session (void *cls, const GNUNET_HashCode * key, void *value)
 714 {
 715   struct SessionDestroyContext *sdc = cls;
 716   struct AllocationRecord *ar = value;
 717
 718   if (ar->session != sdc->session)
 719     return GNUNET_OK;
 720   ar->session = NULL;
 721   if (ar->plugin_addr != NULL)
 722     return GNUNET_OK;
 723   GNUNET_assert (GNUNET_OK ==
 724                  GNUNET_CONTAINER_multihashmap_remove (sdc->atc->peers, key,
 725                                                        ar));
 726   if (GNUNET_YES == ar->connected) ;
 727   {
 728     /* FIXME: is this supposed to be allowed? What to do then? */
 729     GNUNET_break (0);
 730   }
 731   destroy_allocation_record (NULL, key, ar);
 732   return GNUNET_OK;
 733 }
 734
 735
 736 /**
 737  * A session got destroyed, stop including it as a valid address.
 738  *
 739  * @param atc handle
 740  * @param peer identity of the peer
 741  * @param session session handle that is no longer valid
 742  */
 743 void
 744 GNUNET_ATS_session_destroyed (struct GNUNET_ATS_Handle *atc,
 745                               const struct GNUNET_PeerIdentity *peer,
 746                               const struct Session *session)
 747 {
 748   struct SessionDestroyContext sdc;
 749
 750   sdc.atc = atc;
 751   sdc.session = session;
 752   (void) GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &destroy_session,
 753                                                 &sdc);
 754 }
 755
 756
 757 /**
 758  * Notify validation watcher that an entry is now valid
 759  *
 760  * @param cls 'struct ValidationEntry' that is now valid
 761  * @param key peer identity (unused)
 762  * @param value a 'GST_ValidationIteratorContext' to notify
 763  * @return GNUNET_YES (continue to iterate)
 764  */
 765 static int
 766 notify_valid (void *cls, const GNUNET_HashCode * key, void *value)
 767 {
 768   struct AllocationRecord *ar = cls;
 769   struct GNUNET_ATS_SuggestionContext *asc = value;
 770
 771   asc->cb (asc->cb_cls, &asc->target, ar->plugin_name, ar->plugin_addr,
 772            ar->plugin_addr_len, ar->session,
 773            GNUNET_BANDWIDTH_value_init (asc->atc->total_bps / 32), ar->ats,
 774            ar->ats_count);
 775   GNUNET_ATS_suggest_address_cancel (asc);
 776   asc = NULL;
 777   return GNUNET_OK;
 778 }
 779
 780
 781 /**
 782  * We have updated performance statistics for a given address.  Note
 783  * that this function can be called for addresses that are currently
 784  * in use as well as addresses that are valid but not actively in use.
 785  * Furthermore, the peer may not even be connected to us right now (in
 786  * which case the call may be ignored or the information may be stored
 787  * for later use).  Update bandwidth assignments.
 788  *
 789  * @param atc handle
 790  * @param peer identity of the peer
 791  * @param valid_until how long is the address valid?
 792  * @param plugin_name name of the transport plugin
 793  * @param session session handle (if available)
 794  * @param plugin_addr address  (if available)
 795  * @param plugin_addr_len number of bytes in plugin_addr
 796  * @param ats performance data for the address
 797  * @param ats_count number of performance records in 'ats'
 798  */
 799 void
 800 GNUNET_ATS_address_update (struct GNUNET_ATS_Handle *atc,
 801                            const struct GNUNET_PeerIdentity *peer,
 802                            struct GNUNET_TIME_Absolute valid_until,
 803                            const char *plugin_name, struct Session *session,
 804                            const void *plugin_addr, size_t plugin_addr_len,
 805                            const struct GNUNET_TRANSPORT_ATS_Information *ats,
 806                            uint32_t ats_count)
 807 {
 808   struct AllocationRecord *ar;
 809   struct UpdateSessionContext usc;
 810
 811
 812 #if DEBUG_ATS
 813   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api",
 814                    "Updating address for peer `%s', plugin `%s'\n",
 815                    GNUNET_i2s (peer), plugin_name);
 816 #endif
 817
 818   ar = create_allocation_record (plugin_name, session, plugin_addr,
 819                                  plugin_addr_len, ats, ats_count);
 820   usc.atc = atc;
 821   usc.arnew = ar;
 822   if (GNUNET_SYSERR ==
 823       GNUNET_CONTAINER_multihashmap_iterate (atc->peers, &update_session, &usc))
 824   {
 825     destroy_allocation_record (NULL, &peer->hashPubKey, ar);
 826     return;
 827   }
 828 #if DEBUG_ATS
 829   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "ats-api",
 830                    "Adding new address for peer `%s', plugin `%s'\n",
 831                    GNUNET_i2s (peer), plugin_name);
 832 #endif
 833   GNUNET_assert (GNUNET_OK ==
 834                  GNUNET_CONTAINER_multihashmap_put (atc->peers,
 835                                                     &peer->hashPubKey, ar,
 836                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 837   GNUNET_CONTAINER_multihashmap_get_multiple (atc->notify_map,
 838                                               &peer->hashPubKey, &notify_valid,
 839                                               ar);
 840 }
 841
 842 /* end of file gnunet-service-transport_ats.c */