contrib/wpa/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", MAC2STR(entry->aa), entry->network_ctx);
 267         wpa_sm_add_pmkid(pmksa->sm, entry->network_ctx, entry->aa, entry->pmkid,
 268                          entry->fils_cache_id_set ? entry->fils_cache_id : NULL,
 269                          entry->pmk, entry->pmk_len);
 270
 271         return entry;
 272 }
 273
 274
 275 /**
 276  * pmksa_cache_flush - Flush PMKSA cache entries for a specific network
 277  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 278  * @network_ctx: Network configuration context or %NULL to flush all entries
 279  * @pmk: PMK to match for or %NYLL to match all PMKs
 280  * @pmk_len: PMK length
 281  */
 282 void pmksa_cache_flush(struct rsn_pmksa_cache *pmksa, void *network_ctx,
 283                        const u8 *pmk, size_t pmk_len)
 284 {
 285         struct rsn_pmksa_cache_entry *entry, *prev = NULL, *tmp;
 286         int removed = 0;
 287
 288         entry = pmksa->pmksa;
 289         while (entry) {
 290                 if ((entry->network_ctx == network_ctx ||
 291                      network_ctx == NULL) &&
 292                     (pmk == NULL ||
 293                      (pmk_len == entry->pmk_len &&
 294                       os_memcmp(pmk, entry->pmk, pmk_len) == 0))) {
 295                         wpa_printf(MSG_DEBUG, "RSN: Flush PMKSA cache entry "
 296                                    "for " MACSTR, MAC2STR(entry->aa));
 297                         if (prev)
 298                                 prev->next = entry->next;
 299                         else
 300                                 pmksa->pmksa = entry->next;
 301                         tmp = entry;
 302                         entry = entry->next;
 303                         pmksa_cache_free_entry(pmksa, tmp, PMKSA_FREE);
 304                         removed++;
 305                 } else {
 306                         prev = entry;
 307                         entry = entry->next;
 308                 }
 309         }
 310         if (removed)
 311                 pmksa_cache_set_expiration(pmksa);
 312 }
 313
 314
 315 /**
 316  * pmksa_cache_deinit - Free all entries in PMKSA cache
 317  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 318  */
 319 void pmksa_cache_deinit(struct rsn_pmksa_cache *pmksa)
 320 {
 321         struct rsn_pmksa_cache_entry *entry, *prev;
 322
 323         if (pmksa == NULL)
 324                 return;
 325
 326         entry = pmksa->pmksa;
 327         pmksa->pmksa = NULL;
 328         while (entry) {
 329                 prev = entry;
 330                 entry = entry->next;
 331                 os_free(prev);
 332         }
 333         pmksa_cache_set_expiration(pmksa);
 334         os_free(pmksa);
 335 }
 336
 337
 338 /**
 339  * pmksa_cache_get - Fetch a PMKSA cache entry
 340  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 341  * @aa: Authenticator address or %NULL to match any
 342  * @pmkid: PMKID or %NULL to match any
 343  * @network_ctx: Network context or %NULL to match any
 344  * @akmp: Specific AKMP to search for or 0 for any
 345  * Returns: Pointer to PMKSA cache entry or %NULL if no match was found
 346  */
 347 struct rsn_pmksa_cache_entry * pmksa_cache_get(struct rsn_pmksa_cache *pmksa,
 348                                                const u8 *aa, const u8 *pmkid,
 349                                                const void *network_ctx,
 350                                                int akmp)
 351 {
 352         struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
 353         while (entry) {
 354                 if ((aa == NULL || os_memcmp(entry->aa, aa, ETH_ALEN) == 0) &&
 355                     (pmkid == NULL ||
 356                      os_memcmp(entry->pmkid, pmkid, PMKID_LEN) == 0) &&
 357                     (!akmp || akmp == entry->akmp) &&
 358                     (network_ctx == NULL || network_ctx == entry->network_ctx))
 359                         return entry;
 360                 entry = entry->next;
 361         }
 362         return NULL;
 363 }
 364
 365
 366 static struct rsn_pmksa_cache_entry *
 367 pmksa_cache_clone_entry(struct rsn_pmksa_cache *pmksa,
 368                         const struct rsn_pmksa_cache_entry *old_entry,
 369                         const u8 *aa)
 370 {
 371         struct rsn_pmksa_cache_entry *new_entry;
 372         os_time_t old_expiration = old_entry->expiration;
 373
 374         new_entry = pmksa_cache_add(pmksa, old_entry->pmk, old_entry->pmk_len,
 375                                     NULL, NULL, 0,
 376                                     aa, pmksa->sm->own_addr,
 377                                     old_entry->network_ctx, old_entry->akmp,
 378                                     old_entry->fils_cache_id_set ?
 379                                     old_entry->fils_cache_id : NULL);
 380         if (new_entry == NULL)
 381                 return NULL;
 382
 383         /* TODO: reorder entries based on expiration time? */
 384         new_entry->expiration = old_expiration;
 385         new_entry->opportunistic = 1;
 386
 387         return new_entry;
 388 }
 389
 390
 391 /**
 392  * pmksa_cache_get_opportunistic - Try to get an opportunistic PMKSA entry
 393  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 394  * @network_ctx: Network configuration context
 395  * @aa: Authenticator address for the new AP
 396  * @akmp: Specific AKMP to search for or 0 for any
 397  * Returns: Pointer to a new PMKSA cache entry or %NULL if not available
 398  *
 399  * Try to create a new PMKSA cache entry opportunistically by guessing that the
 400  * new AP is sharing the same PMK as another AP that has the same SSID and has
 401  * already an entry in PMKSA cache.
 402  */
 403 struct rsn_pmksa_cache_entry *
 404 pmksa_cache_get_opportunistic(struct rsn_pmksa_cache *pmksa, void *network_ctx,
 405                               const u8 *aa, int akmp)
 406 {
 407         struct rsn_pmksa_cache_entry *entry = pmksa->pmksa;
 408
 409         wpa_printf(MSG_DEBUG, "RSN: Consider " MACSTR " for OKC", MAC2STR(aa));
 410         if (network_ctx == NULL)
 411                 return NULL;
 412         while (entry) {
 413                 if (entry->network_ctx == network_ctx &&
 414                     (!akmp || entry->akmp == akmp)) {
 415                         entry = pmksa_cache_clone_entry(pmksa, entry, aa);
 416                         if (entry) {
 417                                 wpa_printf(MSG_DEBUG, "RSN: added "
 418                                            "opportunistic PMKSA cache entry "
 419                                            "for " MACSTR, MAC2STR(aa));
 420                         }
 421                         return entry;
 422                 }
 423                 entry = entry->next;
 424         }
 425         return NULL;
 426 }
 427
 428
 429 static struct rsn_pmksa_cache_entry *
 430 pmksa_cache_get_fils_cache_id(struct rsn_pmksa_cache *pmksa,
 431                               const void *network_ctx, const u8 *cache_id)
 432 {
 433         struct rsn_pmksa_cache_entry *entry;
 434
 435         for (entry = pmksa->pmksa; entry; entry = entry->next) {
 436                 if (network_ctx == entry->network_ctx &&
 437                     entry->fils_cache_id_set &&
 438                     os_memcmp(cache_id, entry->fils_cache_id,
 439                               FILS_CACHE_ID_LEN) == 0)
 440                         return entry;
 441         }
 442
 443         return NULL;
 444 }
 445
 446
 447 /**
 448  * pmksa_cache_get_current - Get the current used PMKSA entry
 449  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 450  * Returns: Pointer to the current PMKSA cache entry or %NULL if not available
 451  */
 452 struct rsn_pmksa_cache_entry * pmksa_cache_get_current(struct wpa_sm *sm)
 453 {
 454         if (sm == NULL)
 455                 return NULL;
 456         return sm->cur_pmksa;
 457 }
 458
 459
 460 /**
 461  * pmksa_cache_clear_current - Clear the current PMKSA entry selection
 462  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 463  */
 464 void pmksa_cache_clear_current(struct wpa_sm *sm)
 465 {
 466         if (sm == NULL)
 467                 return;
 468         sm->cur_pmksa = NULL;
 469 }
 470
 471
 472 /**
 473  * pmksa_cache_set_current - Set the current PMKSA entry selection
 474  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 475  * @pmkid: PMKID for selecting PMKSA or %NULL if not used
 476  * @bssid: BSSID for PMKSA or %NULL if not used
 477  * @network_ctx: Network configuration context
 478  * @try_opportunistic: Whether to allow opportunistic PMKSA caching
 479  * @fils_cache_id: Pointer to FILS Cache Identifier or %NULL if not used
 480  * Returns: 0 if PMKSA was found or -1 if no matching entry was found
 481  */
 482 int pmksa_cache_set_current(struct wpa_sm *sm, const u8 *pmkid,
 483                             const u8 *bssid, void *network_ctx,
 484                             int try_opportunistic, const u8 *fils_cache_id,
 485                             int akmp)
 486 {
 487         struct rsn_pmksa_cache *pmksa = sm->pmksa;
 488         wpa_printf(MSG_DEBUG, "RSN: PMKSA cache search - network_ctx=%p "
 489                    "try_opportunistic=%d akmp=0x%x",
 490                    network_ctx, try_opportunistic, akmp);
 491         if (pmkid)
 492                 wpa_hexdump(MSG_DEBUG, "RSN: Search for PMKID",
 493                             pmkid, PMKID_LEN);
 494         if (bssid)
 495                 wpa_printf(MSG_DEBUG, "RSN: Search for BSSID " MACSTR,
 496                            MAC2STR(bssid));
 497         if (fils_cache_id)
 498                 wpa_printf(MSG_DEBUG,
 499                            "RSN: Search for FILS Cache Identifier %02x%02x",
 500                            fils_cache_id[0], fils_cache_id[1]);
 501
 502         sm->cur_pmksa = NULL;
 503         if (pmkid)
 504                 sm->cur_pmksa = pmksa_cache_get(pmksa, NULL, pmkid,
 505                                                 network_ctx, akmp);
 506         if (sm->cur_pmksa == NULL && bssid)
 507                 sm->cur_pmksa = pmksa_cache_get(pmksa, bssid, NULL,
 508                                                 network_ctx, akmp);
 509         if (sm->cur_pmksa == NULL && try_opportunistic && bssid)
 510                 sm->cur_pmksa = pmksa_cache_get_opportunistic(pmksa,
 511                                                               network_ctx,
 512                                                               bssid, akmp);
 513         if (sm->cur_pmksa == NULL && fils_cache_id)
 514                 sm->cur_pmksa = pmksa_cache_get_fils_cache_id(pmksa,
 515                                                               network_ctx,
 516                                                               fils_cache_id);
 517         if (sm->cur_pmksa) {
 518                 wpa_hexdump(MSG_DEBUG, "RSN: PMKSA cache entry found - PMKID",
 519                             sm->cur_pmksa->pmkid, PMKID_LEN);
 520                 return 0;
 521         }
 522         wpa_printf(MSG_DEBUG, "RSN: No PMKSA cache entry found");
 523         return -1;
 524 }
 525
 526
 527 /**
 528  * pmksa_cache_list - Dump text list of entries in PMKSA cache
 529  * @pmksa: Pointer to PMKSA cache data from pmksa_cache_init()
 530  * @buf: Buffer for the list
 531  * @len: Length of the buffer
 532  * Returns: number of bytes written to buffer
 533  *
 534  * This function is used to generate a text format representation of the
 535  * current PMKSA cache contents for the ctrl_iface PMKSA command.
 536  */
 537 int pmksa_cache_list(struct rsn_pmksa_cache *pmksa, char *buf, size_t len)
 538 {
 539         int i, ret;
 540         char *pos = buf;
 541         struct rsn_pmksa_cache_entry *entry;
 542         struct os_reltime now;
 543         int cache_id_used = 0;
 544
 545         for (entry = pmksa->pmksa; entry; entry = entry->next) {
 546                 if (entry->fils_cache_id_set) {
 547                         cache_id_used = 1;
 548                         break;
 549                 }
 550         }
 551
 552         os_get_reltime(&now);
 553         ret = os_snprintf(pos, buf + len - pos,
 554                           "Index / AA / PMKID / expiration (in seconds) / "
 555                           "opportunistic%s\n",
 556                           cache_id_used ? " / FILS Cache Identifier" : "");
 557         if (os_snprintf_error(buf + len - pos, ret))
 558                 return pos - buf;
 559         pos += ret;
 560         i = 0;
 561         entry = pmksa->pmksa;
 562         while (entry) {
 563                 i++;
 564                 ret = os_snprintf(pos, buf + len - pos, "%d " MACSTR " ",
 565                                   i, MAC2STR(entry->aa));
 566                 if (os_snprintf_error(buf + len - pos, ret))
 567                         return pos - buf;
 568                 pos += ret;
 569                 pos += wpa_snprintf_hex(pos, buf + len - pos, entry->pmkid,
 570                                         PMKID_LEN);
 571                 ret = os_snprintf(pos, buf + len - pos, " %d %d",
 572                                   (int) (entry->expiration - now.sec),
 573                                   entry->opportunistic);
 574                 if (os_snprintf_error(buf + len - pos, ret))
 575                         return pos - buf;
 576                 pos += ret;
 577                 if (entry->fils_cache_id_set) {
 578                         ret = os_snprintf(pos, buf + len - pos, " %02x%02x",
 579                                           entry->fils_cache_id[0],
 580                                           entry->fils_cache_id[1]);
 581                         if (os_snprintf_error(buf + len - pos, ret))
 582                                 return pos - buf;
 583                         pos += ret;
 584                 }
 585                 ret = os_snprintf(pos, buf + len - pos, "\n");
 586                 if (os_snprintf_error(buf + len - pos, ret))
 587                         return pos - buf;
 588                 pos += ret;
 589                 entry = entry->next;
 590         }
 591         return pos - buf;
 592 }
 593
 594
 595 struct rsn_pmksa_cache_entry * pmksa_cache_head(struct rsn_pmksa_cache *pmksa)
 596 {
 597         return pmksa->pmksa;
 598 }
 599
 600
 601 /**
 602  * pmksa_cache_init - Initialize PMKSA cache
 603  * @free_cb: Callback function to be called when a PMKSA cache entry is freed
 604  * @ctx: Context pointer for free_cb function
 605  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 606  * Returns: Pointer to PMKSA cache data or %NULL on failure
 607  */
 608 struct rsn_pmksa_cache *
 609 pmksa_cache_init(void (*free_cb)(struct rsn_pmksa_cache_entry *entry,
 610                                  void *ctx, enum pmksa_free_reason reason),
 611                  void *ctx, struct wpa_sm *sm)
 612 {
 613         struct rsn_pmksa_cache *pmksa;
 614
 615         pmksa = os_zalloc(sizeof(*pmksa));
 616         if (pmksa) {
 617                 pmksa->free_cb = free_cb;
 618                 pmksa->ctx = ctx;
 619                 pmksa->sm = sm;
 620         }
 621
 622         return pmksa;
 623 }
 624
 625 #endif /* IEEE8021X_EAPOL */