src/ats/gnunet-service-ats_preferences.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  * @file ats/gnunet-service-ats_preferences.c
  22  * @brief manage preferences expressed by clients
  23  * @author Matthias Wachs
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet-service-ats.h"
  28 #include "gnunet-service-ats_addresses.h"
  29 #include "gnunet-service-ats_performance.h"
  30 #include "gnunet-service-ats_plugins.h"
  31 #include "gnunet-service-ats_preferences.h"
  32 #include "gnunet-service-ats_reservations.h"
  33 #include "ats.h"
  34
  35 #define LOG(kind,...) GNUNET_log_from (kind, "ats-preferences",__VA_ARGS__)
  36
  37 /**
  38  * How frequently do we age preference values?
  39  */
  40 #define PREF_AGING_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
  41
  42 /**
  43  * By which factor do we age preferences expressed during
  44  * each #PREF_AGING_INTERVAL?
  45  */
  46 #define PREF_AGING_FACTOR 0.95
  47
  48 /**
  49  * What is the lowest threshold up to which prefernce values
  50  * are aged, and below which we consider them zero and thus
  51  * no longer subject to aging?
  52  */
  53 #define PREF_EPSILON 0.01
  54
  55
  56 /**
  57  * Relative preferences for a peer.
  58  */
  59 struct PeerRelative
  60 {
  61   /**
  62    * Array of relative preference values, to be indexed by
  63    * an `enum GNUNET_ATS_PreferenceKind`.
  64    */
  65   double f_rel[GNUNET_ATS_PreferenceCount];
  66
  67   /**
  68    * Number of clients that are expressing a preference for
  69    * this peer. When this counter reaches zero, this entry
  70    * is freed.
  71    */
  72   unsigned int num_clients;
  73 };
  74
  75
  76 /**
  77  * Default values, returned as our preferences if we do not
  78  * have any preferences expressed for a peer.
  79  */
  80 static struct PeerRelative defvalues;
  81
  82
  83 /**
  84  * Preference information per peer and client.
  85  */
  86 struct PreferencePeer
  87 {
  88   /**
  89    * Next in DLL of preference entries for the same client.
  90    */
  91   struct PreferencePeer *next;
  92
  93   /**
  94    * Previous in DLL of preference entries for the same client.
  95    */
  96   struct PreferencePeer *prev;
  97
  98   /**
  99    * Absolute preference values for all preference types
 100    * as expressed by this client for this peer.
 101    */
 102   double f_abs[GNUNET_ATS_PreferenceCount];
 103
 104   /**
 105    * Relative preference values for all preference types,
 106    * normalized in [0..1] based on how the respective
 107    * client scored other peers.
 108    */
 109   double f_rel[GNUNET_ATS_PreferenceCount];
 110
 111 };
 112
 113
 114 /**
 115  * Preference client, as in a client that expressed preferences
 116  * for peers.  This is the information we keep track of for each
 117  * such client.
 118  */
 119 struct PreferenceClient
 120 {
 121
 122   /**
 123    * Next in client list
 124    */
 125   struct PreferenceClient *next;
 126
 127   /**
 128    * Previous in client peer list
 129    */
 130   struct PreferenceClient *prev;
 131
 132   /**
 133    * Client handle
 134    */
 135   struct GNUNET_SERVER_Client *client;
 136
 137   /**
 138    * Mapping peer identities to `struct PreferencePeer` entry
 139    * for the respective peer.
 140    */
 141   struct GNUNET_CONTAINER_MultiPeerMap *peer2pref;
 142
 143   /**
 144    * Array of sums of absolute preferences for all
 145    * peers as expressed by this client.
 146    */
 147   double f_abs_sum[GNUNET_ATS_PreferenceCount];
 148
 149 };
 150
 151
 152 /**
 153  * Hashmap to store peer information for preference normalization.
 154  * Maps the identity of a peer to a `struct PeerRelative` containing
 155  * the current relative preference values for that peer.
 156  */
 157 static struct GNUNET_CONTAINER_MultiPeerMap *preference_peers;
 158
 159 /**
 160  * Clients in DLL: head
 161  */
 162 static struct PreferenceClient *pc_head;
 163
 164 /**
 165  * Clients in DLL: tail
 166  */
 167 static struct PreferenceClient *pc_tail;
 168
 169 /**
 170  * Handle for task we run periodically to age preferences over time.
 171  */
 172 static struct GNUNET_SCHEDULER_Task *aging_task;
 173
 174
 175 /**
 176  * Closure for #sum_relative_preferences().
 177  */
 178 struct SumContext
 179 {
 180   /**
 181    * Where to accumulate the result.
 182    */
 183   double f_rel_total;
 184
 185   /**
 186    * Which kind of preference value are we adding up?
 187    */
 188   enum GNUNET_ATS_PreferenceKind kind;
 189 };
 190
 191
 192 /**
 193  * Add the relative preference for the kind given to the
 194  * closure.
 195  *
 196  * @param cls the `struct SumContext` with the kind and place
 197  *                to store the result
 198  * @param peer ignored
 199  * @param value the `struct PreferencePeer` for getting the rel pref.
 200  * @return #GNUNET_OK
 201  */
 202 static int
 203 sum_relative_preferences (void *cls,
 204                           const struct GNUNET_PeerIdentity *peer,
 205                           void *value)
 206 {
 207   struct SumContext *sum_ctx = cls;
 208   struct PreferencePeer *p_cur = value;
 209
 210   sum_ctx->f_rel_total += p_cur->f_rel[sum_ctx->kind];
 211   return GNUNET_OK;
 212 }
 213
 214
 215 /**
 216  * Update the total releative preference for a peer by summing
 217  * up the relative preferences all clients have for this peer.
 218  *
 219  * @param id peer id of the peer for which we should do the update
 220  * @param kind the kind of preference value to update
 221  * @param rp the relative peer struct where we store the global result
 222  * @return the new relative preference
 223  */
 224 static void
 225 update_relative_values_for_peer (const struct GNUNET_PeerIdentity *id,
 226                                  enum GNUNET_ATS_PreferenceKind kind)
 227 {
 228   struct PreferenceClient *c_cur;
 229   struct SumContext sum_ctx;
 230   struct PeerRelative *rp;
 231
 232   sum_ctx.f_rel_total = 0.0;
 233   sum_ctx.kind = kind;
 234   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
 235     GNUNET_CONTAINER_multipeermap_get_multiple (c_cur->peer2pref,
 236                                                 id,
 237                                                 &sum_relative_preferences,
 238                                                 &sum_ctx);
 239   LOG (GNUNET_ERROR_TYPE_DEBUG,
 240        "Total relative preference for peer `%s' for `%s' is %.3f\n",
 241        GNUNET_i2s (id),
 242        GNUNET_ATS_print_preference_type (kind),
 243        sum_ctx.f_rel_total);
 244   rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
 245                                           id);
 246   GNUNET_assert (NULL != rp);
 247   if (rp->f_rel[kind] != sum_ctx.f_rel_total)
 248   {
 249     rp->f_rel[kind] = sum_ctx.f_rel_total;
 250     GAS_plugin_notify_preference_changed (id,
 251                                           kind,
 252                                           rp->f_rel[kind]);
 253   }
 254 }
 255
 256
 257 /**
 258  * Free a peer's `struct PeerRelative`.
 259  *
 260  * @param cls unused
 261  * @param key the key
 262  * @param value the `struct PeerRelative` to free.
 263  * @return #GNUNET_OK to continue
 264  */
 265 static int
 266 free_peer (void *cls,
 267            const struct GNUNET_PeerIdentity *key,
 268            void *value)
 269 {
 270   struct PeerRelative *rp = value;
 271
 272   GNUNET_assert (GNUNET_YES ==
 273                  GNUNET_CONTAINER_multipeermap_remove (preference_peers,
 274                                                        key,
 275                                                        value));
 276   GNUNET_free (rp);
 277   return GNUNET_OK;
 278 }
 279
 280
 281 /**
 282  * Free `struct PreferencePeer` entry in map.
 283  *
 284  * @param cls the `struct PreferenceClient` with the map
 285  * @param key the peer the entry is for
 286  * @param value the `struct PreferencePeer` entry to free
 287  * @return #GNUNET_OK (continue to iterate)
 288  */
 289 static int
 290 free_preference (void *cls,
 291                  const struct GNUNET_PeerIdentity *key,
 292                  void *value)
 293 {
 294   struct PreferenceClient *pc = cls;
 295   struct PreferencePeer *p = value;
 296   struct PeerRelative *pr;
 297
 298   GNUNET_assert (GNUNET_OK ==
 299                  GNUNET_CONTAINER_multipeermap_remove (pc->peer2pref,
 300                                                        key,
 301                                                        p));
 302   GNUNET_free (p);
 303   pr = GNUNET_CONTAINER_multipeermap_get (preference_peers,
 304                                           key);
 305   GNUNET_assert (NULL != pr);
 306   GNUNET_assert (pr->num_clients > 0);
 307   pr->num_clients--;
 308   if (0 == pr->num_clients)
 309   {
 310     free_peer (NULL,
 311                key,
 312                pr);
 313   }
 314   return GNUNET_OK;
 315 }
 316
 317
 318 /**
 319  * Closure for #age_values().
 320  */
 321 struct AgeContext
 322 {
 323   /**
 324    * Counter of values remaining to update, incremented for each value
 325    * changed (to a new non-zero value).
 326    */
 327   unsigned int values_to_update;
 328
 329   /**
 330    * Client we are currently aging values for.
 331    */
 332   struct PreferenceClient *cur_client;
 333
 334 };
 335
 336
 337 /**
 338  * Age preference values of the given peer.
 339  *
 340  * @param cls a `
 341  * @param peer peer being aged
 342  * @param value the `struct PreferencePeer` for the peer
 343  * @return #GNUNET_OK (continue to iterate)
 344  */
 345 static int
 346 age_values (void *cls,
 347             const struct GNUNET_PeerIdentity *peer,
 348             void *value)
 349 {
 350   struct AgeContext *ac = cls;
 351   struct PreferencePeer *p = value;
 352   unsigned int i;
 353   int dead;
 354
 355   dead = GNUNET_YES;
 356   for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
 357   {
 358     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 359                 "Aging preference for peer `%s'\n",
 360                 GNUNET_i2s (peer));
 361     if (p->f_abs[i] > DEFAULT_ABS_PREFERENCE)
 362       p->f_abs[i] *= PREF_AGING_FACTOR;
 363     if (p->f_abs[i] <= DEFAULT_ABS_PREFERENCE + PREF_EPSILON)
 364     {
 365       p->f_abs[i] = DEFAULT_ABS_PREFERENCE;
 366       p->f_rel[i] = DEFAULT_REL_PREFERENCE;
 367       update_relative_values_for_peer (peer,
 368                                        i);
 369     }
 370     else
 371     {
 372       ac->values_to_update++;
 373       dead = GNUNET_NO;
 374     }
 375   }
 376   if (GNUNET_YES == dead)
 377   {
 378     /* all preferences are zero, remove this entry */
 379     free_preference (ac->cur_client,
 380                      peer,
 381                      p);
 382   }
 383   return GNUNET_OK;
 384 }
 385
 386
 387 /**
 388  * Reduce absolute preferences since they got old.
 389  *
 390  * @param cls unused
 391  * @param tc context
 392  */
 393 static void
 394 preference_aging (void *cls,
 395                   const struct GNUNET_SCHEDULER_TaskContext *tc)
 396 {
 397   struct AgeContext ac;
 398
 399   aging_task = NULL;
 400   ac.values_to_update = 0;
 401   for (ac.cur_client = pc_head; NULL != ac.cur_client; ac.cur_client = ac.cur_client->next)
 402     GNUNET_CONTAINER_multipeermap_iterate (ac.cur_client->peer2pref,
 403                                            &age_values,
 404                                            &ac);
 405   if (ac.values_to_update > 0)
 406   {
 407     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 408                 "Rescheduling aging task due to %u elements remaining to age\n",
 409                 ac.values_to_update);
 410     aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
 411                                                &preference_aging,
 412                                                NULL);
 413   }
 414   else
 415   {
 416     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 417                 "No values to age left, not rescheduling aging task\n");
 418   }
 419 }
 420
 421
 422 /**
 423  * Closure for #update_rel_sum() and #update_abs_sum().
 424  */
 425 struct UpdateContext
 426 {
 427   /**
 428    * Preference client with the sum of all absolute scores.
 429    */
 430   struct PreferenceClient *pc;
 431
 432   /**
 433    * Which kind are we updating?
 434    */
 435   enum GNUNET_ATS_PreferenceKind kind;
 436
 437 };
 438
 439
 440 /**
 441  * Compute updated absolute score for the client based on the
 442  * current absolute scores for each peer.
 443  *
 444  * @param cls a `struct UpdateContext`
 445  * @param peer peer being updated
 446  * @param value the `struct PreferencePeer` for the peer
 447  * @return #GNUNET_OK (continue to iterate)
 448  */
 449 static int
 450 update_abs_sum (void *cls,
 451                 const struct GNUNET_PeerIdentity *peer,
 452                 void *value)
 453 {
 454   struct UpdateContext *uc = cls;
 455   struct PreferencePeer *p_cur = value;
 456
 457   uc->pc->f_abs_sum[uc->kind] += p_cur->f_abs[uc->kind];
 458   return GNUNET_OK;
 459 }
 460
 461
 462 /**
 463  * Compute updated relative score for each peer based on the
 464  * current absolute score given by this client.
 465  *
 466  * @param cls a `struct UpdateContext`
 467  * @param peer peer being updated
 468  * @param value the `struct PreferencePeer` for the peer (updated)
 469  * @return #GNUNET_OK (continue to iterate)
 470  */
 471 static int
 472 update_rel_sum (void *cls,
 473                 const struct GNUNET_PeerIdentity *peer,
 474                 void *value)
 475 {
 476   struct UpdateContext *uc = cls;
 477   struct PreferencePeer *p_cur = value;
 478
 479   p_cur->f_rel[uc->kind] = p_cur->f_abs[uc->kind] / uc->pc->f_abs_sum[uc->kind];
 480   LOG (GNUNET_ERROR_TYPE_DEBUG,
 481        "Client has relative preference for %s for peer `%s' of %.3f\n",
 482        GNUNET_ATS_print_preference_type (uc->kind),
 483        GNUNET_i2s (peer),
 484        p_cur->f_rel[uc->kind]);
 485   return GNUNET_OK;
 486 }
 487
 488
 489 /**
 490  * Recalculate preference for a specific ATS property
 491  *
 492  * @param c the preference client
 493  * @param kind the preference kind
 494  * @return the result
 495  */
 496 static void
 497 recalculate_relative_preferences (struct PreferenceClient *c,
 498                                   enum GNUNET_ATS_PreferenceKind kind)
 499 {
 500   struct UpdateContext uc;
 501
 502   /* For this client: sum of absolute preference values for this preference */
 503   uc.kind = kind;
 504   uc.pc = c;
 505   c->f_abs_sum[kind] = 0.0;
 506
 507   /* For all peers: calculate sum of absolute preferences */
 508   GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
 509                                          &update_abs_sum,
 510                                          &uc);
 511   LOG (GNUNET_ERROR_TYPE_DEBUG,
 512        "Client has sum of total preferences for %s of %.3f\n",
 513        GNUNET_ATS_print_preference_type (kind),
 514        c->f_abs_sum[kind]);
 515
 516   /* For all peers: calculate relative preference */
 517   GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
 518                                          &update_rel_sum,
 519                                          &uc);
 520 }
 521
 522
 523 /**
 524  * The relative preferences of one of the clients have
 525  * changed, update the global preferences for the given
 526  * peer and notify the plugin.
 527  *
 528  * @param value the kind of preference to calculate the
 529  *        new global relative preference values for
 530  * @param key the peer to update relative preference values for
 531  * @param value a `struct PeerRelative`, unused
 532  */
 533 static int
 534 update_iterator (void *cls,
 535                  const struct GNUNET_PeerIdentity *key,
 536                  void *value)
 537 {
 538   enum GNUNET_ATS_PreferenceKind *kind = cls;
 539
 540   update_relative_values_for_peer (key,
 541                                    *kind);
 542   return GNUNET_OK;
 543 }
 544
 545
 546 /**
 547  * Update the absolute preference and calculate the
 548  * new relative preference value.
 549  *
 550  * @param client the client with this preference
 551  * @param peer the peer to change the preference for
 552  * @param kind the kind to change the preference
 553  * @param score_abs the normalized score
 554  */
 555 static void
 556 update_preference (struct GNUNET_SERVER_Client *client,
 557                    const struct GNUNET_PeerIdentity *peer,
 558                    enum GNUNET_ATS_PreferenceKind kind,
 559                    float score_abs)
 560 {
 561   struct PreferenceClient *c_cur;
 562   struct PreferencePeer *p_cur;
 563   struct PeerRelative *r_cur;
 564   unsigned int i;
 565
 566   if (kind >= GNUNET_ATS_PreferenceCount)
 567   {
 568     GNUNET_break(0);
 569     return;
 570   }
 571   LOG (GNUNET_ERROR_TYPE_DEBUG,
 572        "Client changes preference for peer `%s' for `%s' to %.2f\n",
 573        GNUNET_i2s (peer),
 574        GNUNET_ATS_print_preference_type (kind),
 575        score_abs);
 576
 577   /* Find preference client */
 578   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
 579     if (client == c_cur->client)
 580       break;
 581   /* Not found: create new preference client */
 582   if (NULL == c_cur)
 583   {
 584     c_cur = GNUNET_new (struct PreferenceClient);
 585     c_cur->peer2pref = GNUNET_CONTAINER_multipeermap_create (16,
 586                                                              GNUNET_NO);
 587     for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
 588       c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
 589     GNUNET_CONTAINER_DLL_insert (pc_head,
 590                                  pc_tail,
 591                                  c_cur);
 592   }
 593
 594   /* check global peer entry exists */
 595   if (NULL ==
 596       (r_cur = GNUNET_CONTAINER_multipeermap_get (preference_peers,
 597                                                   peer)))
 598   {
 599     /* Create struct for peer */
 600     r_cur = GNUNET_new (struct PeerRelative);
 601     for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
 602       r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
 603     GNUNET_assert (GNUNET_OK ==
 604                    GNUNET_CONTAINER_multipeermap_put (preference_peers,
 605                                                       peer,
 606                                                       r_cur,
 607                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 608   }
 609
 610   /* Find entry for peer */
 611   p_cur = GNUNET_CONTAINER_multipeermap_get (c_cur->peer2pref,
 612                                              peer);
 613   if (NULL == p_cur)
 614   {
 615     /* Not found: create new peer entry */
 616     p_cur = GNUNET_new (struct PreferencePeer);
 617     for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
 618     {
 619       /* Default value per peer absolute preference for a preference*/
 620       p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
 621       /* Default value per peer relative preference for a quality */
 622       p_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
 623     }
 624     GNUNET_assert (GNUNET_YES ==
 625                    GNUNET_CONTAINER_multipeermap_put (c_cur->peer2pref,
 626                                                       peer,
 627                                                       p_cur,
 628                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 629     r_cur->num_clients++;
 630   }
 631
 632   p_cur->f_abs[kind] += score_abs;
 633   recalculate_relative_preferences (c_cur, kind);
 634   GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
 635                                          &update_iterator,
 636                                          &kind);
 637
 638   if (NULL == aging_task)
 639     aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
 640                                                &preference_aging,
 641                                                NULL);
 642 }
 643
 644
 645 /**
 646  * Handle 'preference change' messages from clients.
 647  *
 648  * @param cls unused, NULL
 649  * @param client client that sent the request
 650  * @param message the request message
 651  */
 652 void
 653 GAS_handle_preference_change (void *cls,
 654                               struct GNUNET_SERVER_Client *client,
 655                               const struct GNUNET_MessageHeader *message)
 656 {
 657   const struct ChangePreferenceMessage *msg;
 658   const struct PreferenceInformation *pi;
 659   uint16_t msize;
 660   uint32_t nump;
 661   uint32_t i;
 662
 663   msize = ntohs (message->size);
 664   if (msize < sizeof (struct ChangePreferenceMessage))
 665   {
 666     GNUNET_break (0);
 667     GNUNET_SERVER_receive_done (client,
 668                                 GNUNET_SYSERR);
 669     return;
 670   }
 671   msg = (const struct ChangePreferenceMessage *) message;
 672   nump = ntohl (msg->num_preferences);
 673   if ( (msize !=
 674         sizeof (struct ChangePreferenceMessage) +
 675         nump * sizeof (struct PreferenceInformation)) ||
 676        (UINT16_MAX / sizeof (struct PreferenceInformation) < nump) )
 677   {
 678     GNUNET_break (0);
 679     GNUNET_SERVER_receive_done (client,
 680                                 GNUNET_SYSERR);
 681     return;
 682   }
 683   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 684               "Received PREFERENCE_CHANGE message for peer `%s'\n",
 685               GNUNET_i2s (&msg->peer));
 686   GNUNET_STATISTICS_update (GSA_stats,
 687                             "# preference change requests processed",
 688                             1,
 689                             GNUNET_NO);
 690   pi = (const struct PreferenceInformation *) &msg[1];
 691   GAS_plugin_solver_lock ();
 692   for (i = 0; i < nump; i++)
 693     update_preference (client,
 694                        &msg->peer,
 695                        (enum GNUNET_ATS_PreferenceKind) ntohl (pi[i].preference_kind),
 696                        pi[i].preference_value);
 697   GAS_plugin_solver_unlock ();
 698   GNUNET_SERVER_receive_done (client,
 699                               GNUNET_OK);
 700 }
 701
 702
 703 /**
 704  * Initialize preferences subsystem.
 705  */
 706 void
 707 GAS_preference_init ()
 708 {
 709   unsigned int i;
 710
 711   preference_peers = GNUNET_CONTAINER_multipeermap_create (16,
 712                                                            GNUNET_NO);
 713   for (i = 0; i < GNUNET_ATS_PreferenceCount; i++)
 714     defvalues.f_rel[i] = DEFAULT_REL_PREFERENCE;
 715 }
 716
 717
 718 /**
 719  * Shutdown preferences subsystem.
 720  */
 721 void
 722 GAS_preference_done ()
 723 {
 724   struct PreferenceClient *pc;
 725   struct PreferenceClient *next_pc;
 726
 727   if (NULL != aging_task)
 728   {
 729     GNUNET_SCHEDULER_cancel (aging_task);
 730     aging_task = NULL;
 731   }
 732   next_pc = pc_head;
 733   while (NULL != (pc = next_pc))
 734   {
 735     next_pc = pc->next;
 736     GNUNET_CONTAINER_DLL_remove (pc_head,
 737                                  pc_tail,
 738                                  pc);
 739     GNUNET_CONTAINER_multipeermap_iterate (pc->peer2pref,
 740                                            &free_preference,
 741                                            pc);
 742     GNUNET_CONTAINER_multipeermap_destroy (pc->peer2pref);
 743     GNUNET_free (pc);
 744   }
 745   GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
 746                                          &free_peer,
 747                                          NULL);
 748   GNUNET_CONTAINER_multipeermap_destroy (preference_peers);
 749
 750 }
 751
 752
 753 /**
 754  * Get the normalized preference values for a specific peer or
 755  * the default values if
 756  *
 757  * @param cls ignored
 758  * @param id the peer
 759  * @return pointer to the values, can be indexed with GNUNET_ATS_PreferenceKind,
 760  * default preferences if peer does not exist
 761  */
 762 const double *
 763 GAS_preference_get_by_peer (void *cls,
 764                             const struct GNUNET_PeerIdentity *id)
 765 {
 766   struct PeerRelative *rp;
 767
 768   if (NULL ==
 769       (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
 770                                                id)))
 771   {
 772     return defvalues.f_rel;
 773   }
 774   return rp->f_rel;
 775 }
 776
 777
 778 /**
 779  * A performance client disconnected
 780  *
 781  * @param client the client
 782  */
 783 void
 784 GAS_preference_client_disconnect (struct GNUNET_SERVER_Client *client)
 785 {
 786   struct PreferenceClient *c_cur;
 787
 788   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
 789     if (client == c_cur->client)
 790       break;
 791   if (NULL == c_cur)
 792     return;
 793   GNUNET_CONTAINER_DLL_remove (pc_head,
 794                                pc_tail,
 795                                c_cur);
 796   GNUNET_CONTAINER_multipeermap_iterate (c_cur->peer2pref,
 797                                          &free_preference,
 798                                          c_cur);
 799   GNUNET_CONTAINER_multipeermap_destroy (c_cur->peer2pref);
 800   GNUNET_free (c_cur);
 801 }
 802
 803
 804 /* end of gnunet-service-ats_preferences.c */