src/ats/gnunet-service-ats_preferences.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011-2015 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, 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_PREFERENCE_END];
  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_PREFERENCE_END];
 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_PREFERENCE_END];
 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_PREFERENCE_END];
 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_PREFERENCE_END; 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  */
 392 static void
 393 preference_aging (void *cls)
 394 {
 395   struct AgeContext ac;
 396
 397   aging_task = NULL;
 398   GAS_plugin_solver_lock ();
 399   ac.values_to_update = 0;
 400   for (ac.cur_client = pc_head; NULL != ac.cur_client; ac.cur_client = ac.cur_client->next)
 401     GNUNET_CONTAINER_multipeermap_iterate (ac.cur_client->peer2pref,
 402                                            &age_values,
 403                                            &ac);
 404   GAS_plugin_solver_unlock ();
 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     if (NULL == aging_task)
 411       aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
 412                                                  &preference_aging,
 413                                                  NULL);
 414   }
 415   else
 416   {
 417     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 418                 "No values to age left, not rescheduling aging task\n");
 419   }
 420 }
 421
 422
 423 /**
 424  * Closure for #update_rel_sum() and #update_abs_sum().
 425  */
 426 struct UpdateContext
 427 {
 428   /**
 429    * Preference client with the sum of all absolute scores.
 430    */
 431   struct PreferenceClient *pc;
 432
 433   /**
 434    * Which kind are we updating?
 435    */
 436   enum GNUNET_ATS_PreferenceKind kind;
 437
 438 };
 439
 440
 441 /**
 442  * Compute updated absolute score for the client based on the
 443  * current absolute scores for each peer.
 444  *
 445  * @param cls a `struct UpdateContext`
 446  * @param peer peer being updated
 447  * @param value the `struct PreferencePeer` for the peer
 448  * @return #GNUNET_OK (continue to iterate)
 449  */
 450 static int
 451 update_abs_sum (void *cls,
 452                 const struct GNUNET_PeerIdentity *peer,
 453                 void *value)
 454 {
 455   struct UpdateContext *uc = cls;
 456   struct PreferencePeer *p_cur = value;
 457
 458   uc->pc->f_abs_sum[uc->kind] += p_cur->f_abs[uc->kind];
 459   return GNUNET_OK;
 460 }
 461
 462
 463 /**
 464  * Compute updated relative score for each peer based on the
 465  * current absolute score given by this client.
 466  *
 467  * @param cls a `struct UpdateContext`
 468  * @param peer peer being updated
 469  * @param value the `struct PreferencePeer` for the peer (updated)
 470  * @return #GNUNET_OK (continue to iterate)
 471  */
 472 static int
 473 update_rel_sum (void *cls,
 474                 const struct GNUNET_PeerIdentity *peer,
 475                 void *value)
 476 {
 477   struct UpdateContext *uc = cls;
 478   struct PreferencePeer *p_cur = value;
 479
 480   p_cur->f_rel[uc->kind] = p_cur->f_abs[uc->kind] / uc->pc->f_abs_sum[uc->kind];
 481   LOG (GNUNET_ERROR_TYPE_DEBUG,
 482        "Client has relative preference for %s for peer `%s' of %.3f\n",
 483        GNUNET_ATS_print_preference_type (uc->kind),
 484        GNUNET_i2s (peer),
 485        p_cur->f_rel[uc->kind]);
 486   return GNUNET_OK;
 487 }
 488
 489
 490 /**
 491  * Recalculate preference for a specific ATS property
 492  *
 493  * @param c the preference client
 494  * @param kind the preference kind
 495  * @return the result
 496  */
 497 static void
 498 recalculate_relative_preferences (struct PreferenceClient *c,
 499                                   enum GNUNET_ATS_PreferenceKind kind)
 500 {
 501   struct UpdateContext uc;
 502
 503   /* For this client: sum of absolute preference values for this preference */
 504   uc.kind = kind;
 505   uc.pc = c;
 506   c->f_abs_sum[kind] = 0.0;
 507
 508   /* For all peers: calculate sum of absolute preferences */
 509   GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
 510                                          &update_abs_sum,
 511                                          &uc);
 512   LOG (GNUNET_ERROR_TYPE_DEBUG,
 513        "Client has sum of total preferences for %s of %.3f\n",
 514        GNUNET_ATS_print_preference_type (kind),
 515        c->f_abs_sum[kind]);
 516
 517   /* For all peers: calculate relative preference */
 518   GNUNET_CONTAINER_multipeermap_iterate (c->peer2pref,
 519                                          &update_rel_sum,
 520                                          &uc);
 521 }
 522
 523
 524 /**
 525  * The relative preferences of one of the clients have
 526  * changed, update the global preferences for the given
 527  * peer and notify the plugin.
 528  *
 529  * @param value the kind of preference to calculate the
 530  *        new global relative preference values for
 531  * @param key the peer to update relative preference values for
 532  * @param value a `struct PeerRelative`, unused
 533  */
 534 static int
 535 update_iterator (void *cls,
 536                  const struct GNUNET_PeerIdentity *key,
 537                  void *value)
 538 {
 539   enum GNUNET_ATS_PreferenceKind *kind = cls;
 540
 541   update_relative_values_for_peer (key,
 542                                    *kind);
 543   return GNUNET_OK;
 544 }
 545
 546
 547 /**
 548  * Update the absolute preference and calculate the
 549  * new relative preference value.
 550  *
 551  * @param client the client with this preference
 552  * @param peer the peer to change the preference for
 553  * @param kind the kind to change the preference
 554  * @param score_abs the normalized score
 555  */
 556 static void
 557 update_preference (struct GNUNET_SERVER_Client *client,
 558                    const struct GNUNET_PeerIdentity *peer,
 559                    enum GNUNET_ATS_PreferenceKind kind,
 560                    float score_abs)
 561 {
 562   struct PreferenceClient *c_cur;
 563   struct PreferencePeer *p_cur;
 564   struct PeerRelative *r_cur;
 565   unsigned int i;
 566
 567   if (kind >= GNUNET_ATS_PREFERENCE_END)
 568   {
 569     GNUNET_break(0);
 570     return;
 571   }
 572   LOG (GNUNET_ERROR_TYPE_DEBUG,
 573        "Client changes preference for peer `%s' for `%s' to %.2f\n",
 574        GNUNET_i2s (peer),
 575        GNUNET_ATS_print_preference_type (kind),
 576        score_abs);
 577
 578   /* Find preference client */
 579   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
 580     if (client == c_cur->client)
 581       break;
 582   /* Not found: create new preference client */
 583   if (NULL == c_cur)
 584   {
 585     c_cur = GNUNET_new (struct PreferenceClient);
 586     c_cur->client = client;
 587     c_cur->peer2pref = GNUNET_CONTAINER_multipeermap_create (16,
 588                                                              GNUNET_NO);
 589     for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
 590       c_cur->f_abs_sum[i] = DEFAULT_ABS_PREFERENCE;
 591     GNUNET_CONTAINER_DLL_insert (pc_head,
 592                                  pc_tail,
 593                                  c_cur);
 594   }
 595
 596   /* check global peer entry exists */
 597   if (NULL ==
 598       (r_cur = GNUNET_CONTAINER_multipeermap_get (preference_peers,
 599                                                   peer)))
 600   {
 601     /* Create struct for peer */
 602     r_cur = GNUNET_new (struct PeerRelative);
 603     for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
 604       r_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
 605     GNUNET_assert (GNUNET_OK ==
 606                    GNUNET_CONTAINER_multipeermap_put (preference_peers,
 607                                                       peer,
 608                                                       r_cur,
 609                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 610   }
 611
 612   /* Find entry for peer */
 613   p_cur = GNUNET_CONTAINER_multipeermap_get (c_cur->peer2pref,
 614                                              peer);
 615   if (NULL == p_cur)
 616   {
 617     /* Not found: create new peer entry */
 618     p_cur = GNUNET_new (struct PreferencePeer);
 619     for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
 620     {
 621       /* Default value per peer absolute preference for a preference*/
 622       p_cur->f_abs[i] = DEFAULT_ABS_PREFERENCE;
 623       /* Default value per peer relative preference for a quality */
 624       p_cur->f_rel[i] = DEFAULT_REL_PREFERENCE;
 625     }
 626     GNUNET_assert (GNUNET_YES ==
 627                    GNUNET_CONTAINER_multipeermap_put (c_cur->peer2pref,
 628                                                       peer,
 629                                                       p_cur,
 630                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 631     r_cur->num_clients++;
 632   }
 633
 634   p_cur->f_abs[kind] += score_abs;
 635   recalculate_relative_preferences (c_cur, kind);
 636   GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
 637                                          &update_iterator,
 638                                          &kind);
 639
 640   if (NULL == aging_task)
 641     aging_task = GNUNET_SCHEDULER_add_delayed (PREF_AGING_INTERVAL,
 642                                                &preference_aging,
 643                                                NULL);
 644 }
 645
 646
 647 /**
 648  * Handle 'preference change' messages from clients.
 649  *
 650  * @param cls unused, NULL
 651  * @param client client that sent the request
 652  * @param message the request message
 653  */
 654 void
 655 GAS_handle_preference_change (void *cls,
 656                               struct GNUNET_SERVER_Client *client,
 657                               const struct GNUNET_MessageHeader *message)
 658 {
 659   const struct ChangePreferenceMessage *msg;
 660   const struct PreferenceInformation *pi;
 661   uint16_t msize;
 662   uint32_t nump;
 663   uint32_t i;
 664
 665   msize = ntohs (message->size);
 666   if (msize < sizeof (struct ChangePreferenceMessage))
 667   {
 668     GNUNET_break (0);
 669     GNUNET_SERVER_receive_done (client,
 670                                 GNUNET_SYSERR);
 671     return;
 672   }
 673   msg = (const struct ChangePreferenceMessage *) message;
 674   nump = ntohl (msg->num_preferences);
 675   if ( (msize !=
 676         sizeof (struct ChangePreferenceMessage) +
 677         nump * sizeof (struct PreferenceInformation)) ||
 678        (UINT16_MAX / sizeof (struct PreferenceInformation) < nump) )
 679   {
 680     GNUNET_break (0);
 681     GNUNET_SERVER_receive_done (client,
 682                                 GNUNET_SYSERR);
 683     return;
 684   }
 685   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 686               "Received PREFERENCE_CHANGE message for peer `%s'\n",
 687               GNUNET_i2s (&msg->peer));
 688   GNUNET_STATISTICS_update (GSA_stats,
 689                             "# preference change requests processed",
 690                             1,
 691                             GNUNET_NO);
 692   pi = (const struct PreferenceInformation *) &msg[1];
 693   GAS_plugin_solver_lock ();
 694   for (i = 0; i < nump; i++)
 695     update_preference (client,
 696                        &msg->peer,
 697                        (enum GNUNET_ATS_PreferenceKind) ntohl (pi[i].preference_kind),
 698                        pi[i].preference_value);
 699   GAS_plugin_solver_unlock ();
 700   GNUNET_SERVER_receive_done (client,
 701                               GNUNET_OK);
 702 }
 703
 704
 705 /**
 706  * Initialize preferences subsystem.
 707  */
 708 void
 709 GAS_preference_init ()
 710 {
 711   unsigned int i;
 712
 713   preference_peers = GNUNET_CONTAINER_multipeermap_create (16,
 714                                                            GNUNET_NO);
 715   for (i = 0; i < GNUNET_ATS_PREFERENCE_END; i++)
 716     defvalues.f_rel[i] = DEFAULT_REL_PREFERENCE;
 717 }
 718
 719
 720 /**
 721  * Shutdown preferences subsystem.
 722  */
 723 void
 724 GAS_preference_done ()
 725 {
 726   struct PreferenceClient *pc;
 727   struct PreferenceClient *next_pc;
 728
 729   if (NULL != aging_task)
 730   {
 731     GNUNET_SCHEDULER_cancel (aging_task);
 732     aging_task = NULL;
 733   }
 734   next_pc = pc_head;
 735   while (NULL != (pc = next_pc))
 736   {
 737     next_pc = pc->next;
 738     GNUNET_CONTAINER_DLL_remove (pc_head,
 739                                  pc_tail,
 740                                  pc);
 741     GNUNET_CONTAINER_multipeermap_iterate (pc->peer2pref,
 742                                            &free_preference,
 743                                            pc);
 744     GNUNET_CONTAINER_multipeermap_destroy (pc->peer2pref);
 745     GNUNET_free (pc);
 746   }
 747   GNUNET_CONTAINER_multipeermap_iterate (preference_peers,
 748                                          &free_peer,
 749                                          NULL);
 750   GNUNET_CONTAINER_multipeermap_destroy (preference_peers);
 751
 752 }
 753
 754
 755 /**
 756  * Get the normalized preference values for a specific peer or
 757  * the default values if
 758  *
 759  * @param cls ignored
 760  * @param id the peer
 761  * @return pointer to the values, can be indexed with GNUNET_ATS_PreferenceKind,
 762  * default preferences if peer does not exist
 763  */
 764 const double *
 765 GAS_preference_get_by_peer (void *cls,
 766                             const struct GNUNET_PeerIdentity *id)
 767 {
 768   struct PeerRelative *rp;
 769
 770   if (NULL ==
 771       (rp = GNUNET_CONTAINER_multipeermap_get (preference_peers,
 772                                                id)))
 773   {
 774     return defvalues.f_rel;
 775   }
 776   return rp->f_rel;
 777 }
 778
 779
 780 /**
 781  * A performance client disconnected
 782  *
 783  * @param client the client
 784  */
 785 void
 786 GAS_preference_client_disconnect (struct GNUNET_SERVER_Client *client)
 787 {
 788   struct PreferenceClient *c_cur;
 789
 790   for (c_cur = pc_head; NULL != c_cur; c_cur = c_cur->next)
 791     if (client == c_cur->client)
 792       break;
 793   if (NULL == c_cur)
 794     return;
 795   GNUNET_CONTAINER_DLL_remove (pc_head,
 796                                pc_tail,
 797                                c_cur);
 798   GNUNET_CONTAINER_multipeermap_iterate (c_cur->peer2pref,
 799                                          &free_preference,
 800                                          c_cur);
 801   GNUNET_CONTAINER_multipeermap_destroy (c_cur->peer2pref);
 802   GNUNET_free (c_cur);
 803 }
 804
 805
 806 /* end of gnunet-service-ats_preferences.c */