contrib/wpa_supplicant/src/rsn_supp/pmksa_cache.c

   1 /*
   2  * WPA Supplicant - RSN PMKSA cache
   3  * Copyright (c) 2004-2009, 2011-2015, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "eloop.h"
  13 #include "eapol_supp/eapol_supp_sm.h"
  14 #include "wpa.h"
  15 #include "wpa_i.h"
  16 #include "pmksa_cache.h"
  17
  18 #if defined(IEEE8021X_EAPOL) && !defined(CONFIG_NO_WPA)
  19
  20 static const int pmksa_cache_max_entries = 32;
  21
  22 struct rsn_pmksa_cache {
  23         struct rsn_pmksa_cache_entry *pmksa; /* PMKSA cache */
  24         int pmksa_count; /* number of entries in PMKSA cache */
  25         struct wpa_sm *sm; /* TODO: get rid of this reference(?) */
  26
  27         void (*free_cb)(struct rsn_pmksa_cache_entry *entry, void *ctx,
  28                         enum pmksa_free_reason reason);
  29         void *ctx;
  30 };
  31
  32
  33 static void pmksa_cache_set_expiration(struct rsn_pmksa_cache *pmksa);
  34
  35
  36 static void _pmksa_cache_free_entry(struct rsn_pmksa_cache_entry *entry)
  37 {
  38         bin_clear_free(entry, sizeof(*entry));
  39 }
  40
  41
  42 static void pmksa_cache_free_entry(struct rsn_pmksa_cache *pmksa,
  43                                    struct rsn_pmksa_cache_entry *entry,
  44                                    enum pmksa_free_reason reason)
  45 {
  46         wpa_sm_remove_pmkid(pmksa->sm, entry->network_ctx, entry->aa,
  47                             entry->pmkid,
  48                             entry->fils_cache_id_set ? entry->fils_cache_id :
  49                             NULL);
  50         pmksa->pmksa_count--;
  51         pmksa->free_cb(entry, pmksa->ctx, reason);
  52         _pmksa_cache_free_entry(entry);
  53 }
  54
  55
  56 static void pmksa_cache_expire(void *eloop_ctx, void *timeout_ctx)
  57 {
  58         struct rsn_pmksa_cache *pmksa = eloop_ctx;
  59         struct os_reltime now;
  60
  61         os_get_reltime(&now);
  62         while (pmksa->pmksa && pmksa->pmksa->expiration <= now.sec) {
  63                 struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
  64                 pmksa->pmksa = entry->next;
  65                 wpa_printf(MSG_DEBUG, "RSN: expired PMKSA cache entry for "
  66                            MACSTR, MAC2STR(entry->aa));
  67                 pmksa_cache_free_entry(pmksa, entry, PMKSA_EXPIRE);
  68         }
  69
  70         pmksa_cache_set_expiration(pmksa);
  71 }
  72
  73
  74 static void pmksa_cache_reauth(void *eloop_ctx, void *timeout_ctx)
  75 {
  76         struct rsn_pmksa_cache *pmksa = eloop_ctx;
  77         pmksa->sm->cur_pmksa = NULL;
  78         eapol_sm_request_reauth(pmksa->sm->eapol);
  79 }
  80
  81
  82 static void pmksa_cache_set_expiration(struct rsn_pmksa_cache *pmksa)
  83 {
  84         int sec;
  85         struct rsn_pmksa_cache_entry *entry;
  86         struct os_reltime now;
  87
  88         eloop_cancel_timeout(pmksa_cache_expire, pmksa, NULL);
  89         eloop_cancel_timeout(pmksa_cache_reauth, pmksa, NULL);
  90         if (pmksa->pmksa == NULL)
  91                 return;
  92         os_get_reltime(&now);
  93         sec = pmksa->pmksa->expiration - now.sec;
  94         if (sec < 0)
  95                 sec = 0;
  96         eloop_register_timeout(sec + 1, 0, pmksa_cache_expire, pmksa, NULL);
  97
  98         entry = pmksa->sm->cur_pmksa ? pmksa->sm->cur_pmksa :
  99                 pmksa_cache_get(pmksa, pmksa->sm->bssid, NULL, NULL, 0);
 100         if (entry) {
 101                 sec = pmksa->pmksa->reauth_time - now.sec;
 102                 if (sec < 0)
 103                         sec = 0;
 104                 eloop_register_timeout(sec, 0, pmksa_cache_reauth, pmksa,
 105                                        NULL);
 106         }
 107 }
 108
 109
 110 /**
 111  * pmksa_cache_add - Add a PMKSA cache entry
 112  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 113  * @pmk: The new pairwise master key
 114  * @pmk_len: PMK length in bytes, usually PMK_LEN (32)
 115  * @pmkid: Calculated PMKID
 116  * @kck: Key confirmation key or %NULL if not yet derived
 117  * @kck_len: KCK length in bytes
 118  * @aa: Authenticator address
 119  * @spa: Supplicant address
 120  * @network_ctx: Network configuration context for this PMK
 121  * @akmp: WPA_KEY_MGMT_* used in key derivation
 122  * @cache_id: Pointer to FILS Cache Identifier or %NULL if not advertised
 123  * Returns: Pointer to the added PMKSA cache entry or %NULL on error
 124  *
 125  * This function create a PMKSA entry for a new PMK and adds it to the PMKSA
 126  * cache. If an old entry is already in the cache for the same Authenticator,
 127  * this entry will be replaced with the new entry. PMKID will be calculated
 128  * based on the PMK and the driver interface is notified of the new PMKID.
 129  */
 130 struct rsn_pmksa_cache_entry *
 131 pmksa_cache_add(struct rsn_pmksa_cache *pmksa, const u8 *pmk, size_t pmk_len,
 132                 const u8 *pmkid, const u8 *kck, size_t kck_len,
 133                 const u8 *aa, const u8 *spa, void *network_ctx, int akmp,
 134                 const u8 *cache_id)
 135 {
 136         struct rsn_pmksa_cache_entry *entry;
 137         struct os_reltime now;
 138
 139         if (pmk_len > PMK_LEN_MAX)
 140                 return NULL;
 141
 142         if (wpa_key_mgmt_suite_b(akmp) && !kck)
 143                 return NULL;
 144
 145         entry = os_zalloc(sizeof(*entry));
 146         if (entry == NULL)
 147                 return NULL;
 148         os_memcpy(entry->pmk, pmk, pmk_len);
 149         entry->pmk_len = pmk_len;
 150         if (pmkid)
 151                 os_memcpy(entry->pmkid, pmkid, PMKID_LEN);
 152         else if (akmp == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
 153                 rsn_pmkid_suite_b_192(kck, kck_len, aa, spa, entry->pmkid);
 154         else if (wpa_key_mgmt_suite_b(akmp))
 155                 rsn_pmkid_suite_b(kck, kck_len, aa, spa, entry->pmkid);
 156         else
 157                 rsn_pmkid(pmk, pmk_len, aa, spa, entry->pmkid, akmp);
 158         os_get_reltime(&now);
 159         entry->expiration = now.sec + pmksa->sm->dot11RSNAConfigPMKLifetime;
 160         entry->reauth_time = now.sec + pmksa->sm->dot11RSNAConfigPMKLifetime *
 161                 pmksa->sm->dot11RSNAConfigPMKReauthThreshold / 100;
 162         entry->akmp = akmp;
 163         if (cache_id) {
 164                 entry->fils_cache_id_set = 1;
 165                 os_memcpy(entry->fils_cache_id, cache_id, FILS_CACHE_ID_LEN);
 166         }
 167         os_memcpy(entry->aa, aa, ETH_ALEN);
 168         entry->network_ctx = network_ctx;
 169
 170         return pmksa_cache_add_entry(pmksa, entry);
 171 }
 172
 173
 174 struct rsn_pmksa_cache_entry *
 175 pmksa_cache_add_entry(struct rsn_pmksa_cache *pmksa,
 176                       struct rsn_pmksa_cache_entry *entry)
 177 {
 178         struct rsn_pmksa_cache_entry *pos, *prev;
 179
 180         /* Replace an old entry for the same Authenticator (if found) with the
 181          * new entry */
 182         pos = pmksa->pmksa;
 183         prev = NULL;
 184         while (pos) {
 185                 if (os_memcmp(entry->aa, pos->aa, ETH_ALEN) == 0) {
 186                         if (pos->pmk_len == entry->pmk_len &&
 187                             os_memcmp_const(pos->pmk, entry->pmk,
 188                                             entry->pmk_len) == 0 &&
 189                             os_memcmp_const(pos->pmkid, entry->pmkid,
 190                                             PMKID_LEN) == 0) {
 191                                 wpa_printf(MSG_DEBUG, "WPA: reusing previous "
 192                                            "PMKSA entry");
 193                                 os_free(entry);
 194                                 return pos;
 195                         }
 196                         if (prev == NULL)
 197                                 pmksa->pmksa = pos->next;
 198                         else
 199                                 prev->next = pos->next;
 200
 201                         /*
 202                          * If OKC is used, there may be other PMKSA cache
 203                          * entries based on the same PMK. These needs to be
 204                          * flushed so that a new entry can be created based on
 205                          * the new PMK. Only clear other entries if they have a
 206                          * matching PMK and this PMK has been used successfully
 207                          * with the current AP, i.e., if opportunistic flag has
 208                          * been cleared in wpa_supplicant_key_neg_complete().
 209                          */
 210                         wpa_printf(MSG_DEBUG, "RSN: Replace PMKSA entry for "
 211                                    "the current AP and any PMKSA cache entry "
 212                                    "that was based on the old PMK");
 213                         if (!pos->opportunistic)
 214                                 pmksa_cache_flush(pmksa, entry->network_ctx,
 215                                                   pos->pmk, pos->pmk_len);
 216                         pmksa_cache_free_entry(pmksa, pos, PMKSA_REPLACE);
 217                         break;
 218                 }
 219                 prev = pos;
 220                 pos = pos->next;
 221         }
 222
 223         if (pmksa->pmksa_count >= pmksa_cache_max_entries && pmksa->pmksa) {
 224                 /* Remove the oldest entry to make room for the new entry */
 225                 pos = pmksa->pmksa;
 226
 227                 if (pos == pmksa->sm->cur_pmksa) {
 228                         /*
 229                          * Never remove the current PMKSA cache entry, since
 230                          * it's in use, and removing it triggers a needless
 231                          * deauthentication.
 232                          */
 233                         pos = pos->next;
 234                         pmksa->pmksa->next = pos ? pos->next : NULL;
 235                 } else
 236                         pmksa->pmksa = pos->next;
 237
 238                 if (pos) {
 239                         wpa_printf(MSG_DEBUG, "RSN: removed the oldest idle "
 240                                    "PMKSA cache entry (for " MACSTR ") to "
 241                                    "make room for new one",
 242                                    MAC2STR(pos->aa));
 243                         pmksa_cache_free_entry(pmksa, pos, PMKSA_FREE);
 244                 }
 245         }
 246
 247         /* Add the new entry; order by expiration time */
 248         pos = pmksa->pmksa;
 249         prev = NULL;
 250         while (pos) {
 251                 if (pos->expiration > entry->expiration)
 252                         break;
 253                 prev = pos;
 254                 pos = pos->next;
 255         }
 256         if (prev == NULL) {
 257                 entry->next = pmksa->pmksa;
 258                 pmksa->pmksa = entry;
 259                 pmksa_cache_set_expiration(pmksa);
 260         } else {
 261                 entry->next = prev->next;
 262                 prev->next = entry;
 263         }
 264         pmksa->pmksa_count++;
 265         wpa_printf(MSG_DEBUG, "RSN: Added PMKSA cache entry for " MACSTR
 266                    " network_ctx=%p akmp=0x%x", MAC2STR(entry->aa),
 267                    entry->network_ctx, entry->akmp);
 268         wpa_sm_add_pmkid(pmksa->sm, entry->network_ctx, entry->aa, entry->pmkid,
 269                          entry->fils_cache_id_set ? entry->fils_cache_id : NULL,
 270                          entry->pmk, entry->pmk_len);
 271
 272         return entry;
 273 }
 274
 275
 276 /**
 277  * pmksa_cache_flush - Flush PMKSA cache entries for a specific network
 278  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 279  * @network_ctx: Network configuration context or %NULL to flush all entries
 280  * @pmk: PMK to match for or %NYLL to match all PMKs
 281  * @pmk_len: PMK length
 282  */
 283 void pmksa_cache_flush(struct rsn_pmksa_cache *pmksa, void *network_ctx,
 284                        const u8 *pmk, size_t pmk_len)
 285 {
 286         struct rsn_pmksa_cache_entry *entry, *prev = NULL, *tmp;
 287         int removed = 0;
 288
 289         entry = pmksa->pmksa;
 290         while (entry) {
 291                 if ((entry->network_ctx == network_ctx ||
 292                      network_ctx == NULL) &&
 293                     (pmk == NULL ||
 294                      (pmk_len == entry->pmk_len &&
 295                       os_memcmp(pmk, entry->pmk, pmk_len) == 0))) {
 296                         wpa_printf(MSG_DEBUG, "RSN: Flush PMKSA cache entry "
 297                                    "for " MACSTR, MAC2STR(entry->aa));
 298                         if (prev)
 299                                 prev->next = entry->next;
 300                         else
 301                                 pmksa->pmksa = entry->next;
 302                         tmp = entry;
 303                         entry = entry->next;
 304                         pmksa_cache_free_entry(pmksa, tmp, PMKSA_FREE);
 305                         removed++;
 306                 } else {
 307                         prev = entry;
 308                         entry = entry->next;
 309                 }
 310         }
 311         if (removed)
 312                 pmksa_cache_set_expiration(pmksa);
 313 }
 314
 315
 316 /**
 317  * pmksa_cache_deinit - Free all entries in PMKSA cache
 318  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 319  */
 320 void pmksa_cache_deinit(struct rsn_pmksa_cache *pmksa)
 321 {
 322         struct rsn_pmksa_cache_entry *entry, *prev;
 323
 324         if (pmksa == NULL)
 325                 return;
 326
 327         entry = pmksa->pmksa;
 328         pmksa->pmksa = NULL;
 329         while (entry) {
 330                 prev = entry;
 331                 entry = entry->next;
 332                 os_free(prev);
 333         }
 334         pmksa_cache_set_expiration(pmksa);
 335         os_free(pmksa);
 336 }
 337
 338
 339 /**
 340  * pmksa_cache_get - Fetch a PMKSA cache entry
 341  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 342  * @aa: Authenticator address or %NULL to match any
 343  * @pmkid: PMKID or %NULL to match any
 344  * @network_ctx: Network context or %NULL to match any
 345  * @akmp: Specific AKMP to search for or 0 for any
 346  * Returns: Pointer to PMKSA cache entry or %NULL if no match was found
 347  */
 348 struct rsn_pmksa_cache_entry * pmksa_cache_get(struct rsn_pmksa_cache *pmksa,
 349                                                const u8 *aa, const u8 *pmkid,
 350                                                const void *network_ctx,
 351                                                int akmp)
 352 {
 353         struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
 354         while (entry) {
 355                 if ((aa == NULL || os_memcmp(entry->aa, aa, ETH_ALEN) == 0) &&
 356                     (pmkid == NULL ||
 357                      os_memcmp(entry->pmkid, pmkid, PMKID_LEN) == 0) &&
 358                     (!akmp || akmp == entry->akmp) &&
 359                     (network_ctx == NULL || network_ctx == entry->network_ctx))
 360                         return entry;
 361                 entry = entry->next;
 362         }
 363         return NULL;
 364 }
 365
 366
 367 static struct rsn_pmksa_cache_entry *
 368 pmksa_cache_clone_entry(struct rsn_pmksa_cache *pmksa,
 369                         const struct rsn_pmksa_cache_entry *old_entry,
 370                         const u8 *aa)
 371 {
 372         struct rsn_pmksa_cache_entry *new_entry;
 373         os_time_t old_expiration = old_entry->expiration;
 374
 375         new_entry = pmksa_cache_add(pmksa, old_entry->pmk, old_entry->pmk_len,
 376                                     NULL, NULL, 0,
 377                                     aa, pmksa->sm->own_addr,
 378                                     old_entry->network_ctx, old_entry->akmp,
 379                                     old_entry->fils_cache_id_set ?
 380                                     old_entry->fils_cache_id : NULL);
 381         if (new_entry == NULL)
 382                 return NULL;
 383
 384         /* TODO: reorder entries based on expiration time? */
 385         new_entry->expiration = old_expiration;
 386         new_entry->opportunistic = 1;
 387
 388         return new_entry;
 389 }
 390
 391
 392 /**
 393  * pmksa_cache_get_opportunistic - Try to get an opportunistic PMKSA entry
 394  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 395  * @network_ctx: Network configuration context
 396  * @aa: Authenticator address for the new AP
 397  * @akmp: Specific AKMP to search for or 0 for any
 398  * Returns: Pointer to a new PMKSA cache entry or %NULL if not available
 399  *
 400  * Try to create a new PMKSA cache entry opportunistically by guessing that the
 401  * new AP is sharing the same PMK as another AP that has the same SSID and has
 402  * already an entry in PMKSA cache.
 403  */
 404 struct rsn_pmksa_cache_entry *
 405 pmksa_cache_get_opportunistic(struct rsn_pmksa_cache *pmksa, void *network_ctx,
 406                               const u8 *aa, int akmp)
 407 {
 408         struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
 409
 410         wpa_printf(MSG_DEBUG, "RSN: Consider " MACSTR " for OKC", MAC2STR(aa));
 411         if (network_ctx == NULL)
 412                 return NULL;
 413         while (entry) {
 414                 if (entry->network_ctx == network_ctx &&
 415                     (!akmp || entry->akmp == akmp)) {
 416                         entry = pmksa_cache_clone_entry(pmksa, entry, aa);
 417                         if (entry) {
 418                                 wpa_printf(MSG_DEBUG, "RSN: added "
 419                                            "opportunistic PMKSA cache entry "
 420                                            "for " MACSTR, MAC2STR(aa));
 421                         }
 422                         return entry;
 423                 }
 424                 entry = entry->next;
 425         }
 426         return NULL;
 427 }
 428
 429
 430 static struct rsn_pmksa_cache_entry *
 431 pmksa_cache_get_fils_cache_id(struct rsn_pmksa_cache *pmksa,
 432                               const void *network_ctx, const u8 *cache_id)
 433 {
 434         struct rsn_pmksa_cache_entry *entry;
 435
 436         for (entry = pmksa->pmksa; entry; entry = entry->next) {
 437                 if (network_ctx == entry->network_ctx &&
 438                     entry->fils_cache_id_set &&
 439                     os_memcmp(cache_id, entry->fils_cache_id,
 440                               FILS_CACHE_ID_LEN) == 0)
 441                         return entry;
 442         }
 443
 444         return NULL;
 445 }
 446
 447
 448 /**
 449  * pmksa_cache_get_current - Get the current used PMKSA entry
 450  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 451  * Returns: Pointer to the current PMKSA cache entry or %NULL if not available
 452  */
 453 struct rsn_pmksa_cache_entry * pmksa_cache_get_current(struct wpa_sm *sm)
 454 {
 455         if (sm == NULL)
 456                 return NULL;
 457         return sm->cur_pmksa;
 458 }
 459
 460
 461 /**
 462  * pmksa_cache_clear_current - Clear the current PMKSA entry selection
 463  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 464  */
 465 void pmksa_cache_clear_current(struct wpa_sm *sm)
 466 {
 467         if (sm == NULL)
 468                 return;
 469         sm->cur_pmksa = NULL;
 470 }
 471
 472
 473 /**
 474  * pmksa_cache_set_current - Set the current PMKSA entry selection
 475  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 476  * @pmkid: PMKID for selecting PMKSA or %NULL if not used
 477  * @bssid: BSSID for PMKSA or %NULL if not used
 478  * @network_ctx: Network configuration context
 479  * @try_opportunistic: Whether to allow opportunistic PMKSA caching
 480  * @fils_cache_id: Pointer to FILS Cache Identifier or %NULL if not used
 481  * Returns: 0 if PMKSA was found or -1 if no matching entry was found
 482  */
 483 int pmksa_cache_set_current(struct wpa_sm *sm, const u8 *pmkid,
 484                             const u8 *bssid, void *network_ctx,
 485                             int try_opportunistic, const u8 *fils_cache_id,
 486                             int akmp)
 487 {
 488         struct rsn_pmksa_cache *pmksa = sm->pmksa;
 489         wpa_printf(MSG_DEBUG, "RSN: PMKSA cache search - network_ctx=%p "
 490                    "try_opportunistic=%d akmp=0x%x",
 491                    network_ctx, try_opportunistic, akmp);
 492         if (pmkid)
 493                 wpa_hexdump(MSG_DEBUG, "RSN: Search for PMKID",
 494                             pmkid, PMKID_LEN);
 495         if (bssid)
 496                 wpa_printf(MSG_DEBUG, "RSN: Search for BSSID " MACSTR,
 497                            MAC2STR(bssid));
 498         if (fils_cache_id)
 499                 wpa_printf(MSG_DEBUG,
 500                            "RSN: Search for FILS Cache Identifier %02x%02x",
 501                            fils_cache_id[0], fils_cache_id[1]);
 502
 503         sm->cur_pmksa = NULL;
 504         if (pmkid)
 505                 sm->cur_pmksa = pmksa_cache_get(pmksa, NULL, pmkid,
 506                                                 network_ctx, akmp);
 507         if (sm->cur_pmksa == NULL && bssid)
 508                 sm->cur_pmksa = pmksa_cache_get(pmksa, bssid, NULL,
 509                                                 network_ctx, akmp);
 510         if (sm->cur_pmksa == NULL && try_opportunistic && bssid)
 511                 sm->cur_pmksa = pmksa_cache_get_opportunistic(pmksa,
 512                                                               network_ctx,
 513                                                               bssid, akmp);
 514         if (sm->cur_pmksa == NULL && fils_cache_id)
 515                 sm->cur_pmksa = pmksa_cache_get_fils_cache_id(pmksa,
 516                                                               network_ctx,
 517                                                               fils_cache_id);
 518         if (sm->cur_pmksa) {
 519                 wpa_hexdump(MSG_DEBUG, "RSN: PMKSA cache entry found - PMKID",
 520                             sm->cur_pmksa->pmkid, PMKID_LEN);
 521                 return 0;
 522         }
 523         wpa_printf(MSG_DEBUG, "RSN: No PMKSA cache entry found");
 524         return -1;
 525 }
 526
 527
 528 /**
 529  * pmksa_cache_list - Dump text list of entries in PMKSA cache
 530  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 531  * @buf: Buffer for the list
 532  * @len: Length of the buffer
 533  * Returns: number of bytes written to buffer
 534  *
 535  * This function is used to generate a text format representation of the
 536  * current PMKSA cache contents for the ctrl_iface PMKSA command.
 537  */
 538 int pmksa_cache_list(struct rsn_pmksa_cache *pmksa, char *buf, size_t len)
 539 {
 540         int i, ret;
 541         char *pos = buf;
 542         struct rsn_pmksa_cache_entry *entry;
 543         struct os_reltime now;
 544         int cache_id_used = 0;
 545
 546         for (entry = pmksa->pmksa; entry; entry = entry->next) {
 547                 if (entry->fils_cache_id_set) {
 548                         cache_id_used = 1;
 549                         break;
 550                 }
 551         }
 552
 553         os_get_reltime(&now);
 554         ret = os_snprintf(pos, buf + len - pos,
 555                           "Index / AA / PMKID / expiration (in seconds) / "
 556                           "opportunistic%s\n",
 557                           cache_id_used ? " / FILS Cache Identifier" : "");
 558         if (os_snprintf_error(buf + len - pos, ret))
 559                 return pos - buf;
 560         pos += ret;
 561         i = 0;
 562         entry = pmksa->pmksa;
 563         while (entry) {
 564                 i++;
 565                 ret = os_snprintf(pos, buf + len - pos, "%d " MACSTR " ",
 566                                   i, MAC2STR(entry->aa));
 567                 if (os_snprintf_error(buf + len - pos, ret))
 568                         return pos - buf;
 569                 pos += ret;
 570                 pos += wpa_snprintf_hex(pos, buf + len - pos, entry->pmkid,
 571                                         PMKID_LEN);
 572                 ret = os_snprintf(pos, buf + len - pos, " %d %d",
 573                                   (int) (entry->expiration - now.sec),
 574                                   entry->opportunistic);
 575                 if (os_snprintf_error(buf + len - pos, ret))
 576                         return pos - buf;
 577                 pos += ret;
 578                 if (entry->fils_cache_id_set) {
 579                         ret = os_snprintf(pos, buf + len - pos, " %02x%02x",
 580                                           entry->fils_cache_id[0],
 581                                           entry->fils_cache_id[1]);
 582                         if (os_snprintf_error(buf + len - pos, ret))
 583                                 return pos - buf;
 584                         pos += ret;
 585                 }
 586                 ret = os_snprintf(pos, buf + len - pos, "\n");
 587                 if (os_snprintf_error(buf + len - pos, ret))
 588                         return pos - buf;
 589                 pos += ret;
 590                 entry = entry->next;
 591         }
 592         return pos - buf;
 593 }
 594
 595
 596 struct rsn_pmksa_cache_entry * pmksa_cache_head(struct rsn_pmksa_cache *pmksa)
 597 {
 598         return pmksa->pmksa;
 599 }
 600
 601
 602 /**
 603  * pmksa_cache_init - Initialize PMKSA cache
 604  * @free_cb: Callback function to be called when a PMKSA cache entry is freed
 605  * @ctx: Context pointer for free_cb function
 606  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 607  * Returns: Pointer to PMKSA cache data or %NULL on failure
 608  */
 609 struct rsn_pmksa_cache *
 610 pmksa_cache_init(void (*free_cb)(struct rsn_pmksa_cache_entry *entry,
 611                                  void *ctx, enum pmksa_free_reason reason),
 612                  void *ctx, struct wpa_sm *sm)
 613 {
 614         struct rsn_pmksa_cache *pmksa;
 615
 616         pmksa = os_zalloc(sizeof(*pmksa));
 617         if (pmksa) {
 618                 pmksa->free_cb = free_cb;
 619                 pmksa->ctx = ctx;
 620                 pmksa->sm = sm;
 621         }
 622
 623         return pmksa;
 624 }
 625
 626 #endif /* IEEE8021X_EAPOL */