wpa_supplicant/wpas_glue.c

   1 /*
   2  * WPA Supplicant - Glue code to setup EAPOL and RSN modules
   3  * Copyright (c) 2003-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 "eapol_supp/eapol_supp_sm.h"
  13 #include "eap_peer/eap.h"
  14 #include "rsn_supp/wpa.h"
  15 #include "eloop.h"
  16 #include "config.h"
  17 #include "l2_packet/l2_packet.h"
  18 #include "common/wpa_common.h"
  19 #include "wpa_supplicant_i.h"
  20 #include "driver_i.h"
  21 #include "rsn_supp/pmksa_cache.h"
  22 #include "sme.h"
  23 #include "common/ieee802_11_defs.h"
  24 #include "common/wpa_ctrl.h"
  25 #include "wpas_glue.h"
  26 #include "wps_supplicant.h"
  27 #include "bss.h"
  28 #include "scan.h"
  29 #include "notify.h"
  30 #include "wpas_kay.h"
  31
  32
  33 #ifndef CONFIG_NO_CONFIG_BLOBS
  34 #if defined(IEEE8021X_EAPOL) || !defined(CONFIG_NO_WPA)
  35 static void wpa_supplicant_set_config_blob(void *ctx,
  36                                            struct wpa_config_blob *blob)
  37 {
  38         struct wpa_supplicant *wpa_s = ctx;
  39         wpa_config_set_blob(wpa_s->conf, blob);
  40         if (wpa_s->conf->update_config) {
  41                 int ret = wpa_config_write(wpa_s->confname, wpa_s->conf);
  42                 if (ret) {
  43                         wpa_printf(MSG_DEBUG, "Failed to update config after "
  44                                    "blob set");
  45                 }
  46         }
  47 }
  48
  49
  50 static const struct wpa_config_blob *
  51 wpa_supplicant_get_config_blob(void *ctx, const char *name)
  52 {
  53         struct wpa_supplicant *wpa_s = ctx;
  54         return wpa_config_get_blob(wpa_s->conf, name);
  55 }
  56 #endif /* defined(IEEE8021X_EAPOL) || !defined(CONFIG_NO_WPA) */
  57 #endif /* CONFIG_NO_CONFIG_BLOBS */
  58
  59
  60 #if defined(IEEE8021X_EAPOL) || !defined(CONFIG_NO_WPA)
  61 static u8 * wpa_alloc_eapol(const struct wpa_supplicant *wpa_s, u8 type,
  62                             const void *data, u16 data_len,
  63                             size_t *msg_len, void **data_pos)
  64 {
  65         struct ieee802_1x_hdr *hdr;
  66
  67         *msg_len = sizeof(*hdr) + data_len;
  68         hdr = os_malloc(*msg_len);
  69         if (hdr == NULL)
  70                 return NULL;
  71
  72         hdr->version = wpa_s->conf->eapol_version;
  73         hdr->type = type;
  74         hdr->length = host_to_be16(data_len);
  75
  76         if (data)
  77                 os_memcpy(hdr + 1, data, data_len);
  78         else
  79                 os_memset(hdr + 1, 0, data_len);
  80
  81         if (data_pos)
  82                 *data_pos = hdr + 1;
  83
  84         return (u8 *) hdr;
  85 }
  86
  87
  88 /**
  89  * wpa_ether_send - Send Ethernet frame
  90  * @wpa_s: Pointer to wpa_supplicant data
  91  * @dest: Destination MAC address
  92  * @proto: Ethertype in host byte order
  93  * @buf: Frame payload starting from IEEE 802.1X header
  94  * @len: Frame payload length
  95  * Returns: >=0 on success, <0 on failure
  96  */
  97 static int wpa_ether_send(struct wpa_supplicant *wpa_s, const u8 *dest,
  98                           u16 proto, const u8 *buf, size_t len)
  99 {
 100 #ifdef CONFIG_TESTING_OPTIONS
 101         if (wpa_s->ext_eapol_frame_io && proto == ETH_P_EAPOL) {
 102                 size_t hex_len = 2 * len + 1;
 103                 char *hex = os_malloc(hex_len);
 104
 105                 if (hex == NULL)
 106                         return -1;
 107                 wpa_snprintf_hex(hex, hex_len, buf, len);
 108                 wpa_msg(wpa_s, MSG_INFO, "EAPOL-TX " MACSTR " %s",
 109                         MAC2STR(dest), hex);
 110                 os_free(hex);
 111                 return 0;
 112         }
 113 #endif /* CONFIG_TESTING_OPTIONS */
 114
 115         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_CONTROL_PORT) {
 116                 int encrypt = wpa_s->wpa &&
 117                         wpa_sm_has_ptk_installed(wpa_s->wpa);
 118
 119                 return wpa_drv_tx_control_port(wpa_s, dest, proto, buf, len,
 120                                                !encrypt);
 121         }
 122
 123         if (wpa_s->l2) {
 124                 return l2_packet_send(wpa_s->l2, dest, proto, buf, len);
 125         }
 126
 127         return -1;
 128 }
 129 #endif /* IEEE8021X_EAPOL || !CONFIG_NO_WPA */
 130
 131
 132 #ifdef IEEE8021X_EAPOL
 133
 134 /**
 135  * wpa_supplicant_eapol_send - Send IEEE 802.1X EAPOL packet to Authenticator
 136  * @ctx: Pointer to wpa_supplicant data (wpa_s)
 137  * @type: IEEE 802.1X packet type (IEEE802_1X_TYPE_*)
 138  * @buf: EAPOL payload (after IEEE 802.1X header)
 139  * @len: EAPOL payload length
 140  * Returns: >=0 on success, <0 on failure
 141  *
 142  * This function adds Ethernet and IEEE 802.1X header and sends the EAPOL frame
 143  * to the current Authenticator.
 144  */
 145 static int wpa_supplicant_eapol_send(void *ctx, int type, const u8 *buf,
 146                                      size_t len)
 147 {
 148         struct wpa_supplicant *wpa_s = ctx;
 149         u8 *msg, *dst, bssid[ETH_ALEN];
 150         size_t msglen;
 151         int res;
 152
 153         /* TODO: could add l2_packet_sendmsg that allows fragments to avoid
 154          * extra copy here */
 155
 156         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
 157             wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
 158             wpa_s->key_mgmt == WPA_KEY_MGMT_DPP ||
 159             wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
 160                 /* Current SSID is not using IEEE 802.1X/EAP, so drop possible
 161                  * EAPOL frames (mainly, EAPOL-Start) from EAPOL state
 162                  * machines. */
 163                 wpa_printf(MSG_DEBUG, "WPA: drop TX EAPOL in non-IEEE 802.1X "
 164                            "mode (type=%d len=%lu)", type,
 165                            (unsigned long) len);
 166                 return -1;
 167         }
 168
 169         if (pmksa_cache_get_current(wpa_s->wpa) &&
 170             type == IEEE802_1X_TYPE_EAPOL_START) {
 171                 /*
 172                  * We were trying to use PMKSA caching and sending EAPOL-Start
 173                  * would abort that and trigger full EAPOL authentication.
 174                  * However, we've already waited for the AP/Authenticator to
 175                  * start 4-way handshake or EAP authentication, and apparently
 176                  * it has not done so since the startWhen timer has reached zero
 177                  * to get the state machine sending EAPOL-Start. This is not
 178                  * really supposed to happen, but an interoperability issue with
 179                  * a deployed AP has been identified where the connection fails
 180                  * due to that AP failing to operate correctly if PMKID is
 181                  * included in the Association Request frame. To work around
 182                  * this, assume PMKSA caching failed and try to initiate full
 183                  * EAP authentication.
 184                  */
 185                 if (!wpa_s->current_ssid ||
 186                     wpa_s->current_ssid->eap_workaround) {
 187                         wpa_printf(MSG_DEBUG,
 188                                    "RSN: Timeout on waiting for the AP to initiate 4-way handshake for PMKSA caching or EAP authentication - try to force it to start EAP authentication");
 189                 } else {
 190                         wpa_printf(MSG_DEBUG,
 191                                    "RSN: PMKSA caching - do not send EAPOL-Start");
 192                         return -1;
 193                 }
 194         }
 195
 196         if (is_zero_ether_addr(wpa_s->bssid)) {
 197                 wpa_printf(MSG_DEBUG, "BSSID not set when trying to send an "
 198                            "EAPOL frame");
 199                 if (wpa_drv_get_bssid(wpa_s, bssid) == 0 &&
 200                     !is_zero_ether_addr(bssid)) {
 201                         dst = bssid;
 202                         wpa_printf(MSG_DEBUG, "Using current BSSID " MACSTR
 203                                    " from the driver as the EAPOL destination",
 204                                    MAC2STR(dst));
 205                 } else {
 206                         dst = wpa_s->last_eapol_src;
 207                         wpa_printf(MSG_DEBUG, "Using the source address of the"
 208                                    " last received EAPOL frame " MACSTR " as "
 209                                    "the EAPOL destination",
 210                                    MAC2STR(dst));
 211                 }
 212         } else {
 213                 /* BSSID was already set (from (Re)Assoc event, so use it as
 214                  * the EAPOL destination. */
 215                 dst = wpa_s->bssid;
 216         }
 217
 218         msg = wpa_alloc_eapol(wpa_s, type, buf, len, &msglen, NULL);
 219         if (msg == NULL)
 220                 return -1;
 221
 222         wpa_printf(MSG_DEBUG, "TX EAPOL: dst=" MACSTR, MAC2STR(dst));
 223         wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", msg, msglen);
 224         res = wpa_ether_send(wpa_s, dst, ETH_P_EAPOL, msg, msglen);
 225         os_free(msg);
 226         return res;
 227 }
 228
 229
 230 /**
 231  * wpa_eapol_set_wep_key - set WEP key for the driver
 232  * @ctx: Pointer to wpa_supplicant data (wpa_s)
 233  * @unicast: 1 = individual unicast key, 0 = broadcast key
 234  * @keyidx: WEP key index (0..3)
 235  * @key: Pointer to key data
 236  * @keylen: Key length in bytes
 237  * Returns: 0 on success or < 0 on error.
 238  */
 239 static int wpa_eapol_set_wep_key(void *ctx, int unicast, int keyidx,
 240                                  const u8 *key, size_t keylen)
 241 {
 242         struct wpa_supplicant *wpa_s = ctx;
 243         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 244                 int cipher = (keylen == 5) ? WPA_CIPHER_WEP40 :
 245                         WPA_CIPHER_WEP104;
 246                 if (unicast)
 247                         wpa_s->pairwise_cipher = cipher;
 248                 else
 249                         wpa_s->group_cipher = cipher;
 250         }
 251         return wpa_drv_set_key(wpa_s, WPA_ALG_WEP,
 252                                unicast ? wpa_s->bssid : NULL,
 253                                keyidx, unicast, NULL, 0, key, keylen,
 254                                unicast ? KEY_FLAG_PAIRWISE_RX_TX :
 255                                KEY_FLAG_GROUP_RX_TX_DEFAULT);
 256 }
 257
 258
 259 static void wpa_supplicant_aborted_cached(void *ctx)
 260 {
 261         struct wpa_supplicant *wpa_s = ctx;
 262         wpa_sm_aborted_cached(wpa_s->wpa);
 263 }
 264
 265
 266 static const char * result_str(enum eapol_supp_result result)
 267 {
 268         switch (result) {
 269         case EAPOL_SUPP_RESULT_FAILURE:
 270                 return "FAILURE";
 271         case EAPOL_SUPP_RESULT_SUCCESS:
 272                 return "SUCCESS";
 273         case EAPOL_SUPP_RESULT_EXPECTED_FAILURE:
 274                 return "EXPECTED_FAILURE";
 275         }
 276         return "?";
 277 }
 278
 279
 280 static void wpa_supplicant_eapol_cb(struct eapol_sm *eapol,
 281                                     enum eapol_supp_result result,
 282                                     void *ctx)
 283 {
 284         struct wpa_supplicant *wpa_s = ctx;
 285         int res, pmk_len;
 286         u8 pmk[PMK_LEN];
 287
 288         wpa_printf(MSG_DEBUG, "EAPOL authentication completed - result=%s",
 289                    result_str(result));
 290
 291         if (wpas_wps_eapol_cb(wpa_s) > 0)
 292                 return;
 293
 294         wpa_s->eap_expected_failure = result ==
 295                 EAPOL_SUPP_RESULT_EXPECTED_FAILURE;
 296
 297         if (result != EAPOL_SUPP_RESULT_SUCCESS) {
 298                 /*
 299                  * Make sure we do not get stuck here waiting for long EAPOL
 300                  * timeout if the AP does not disconnect in case of
 301                  * authentication failure.
 302                  */
 303                 wpa_supplicant_req_auth_timeout(wpa_s, 2, 0);
 304         } else {
 305                 ieee802_1x_notify_create_actor(wpa_s, wpa_s->last_eapol_src);
 306         }
 307
 308         if (result != EAPOL_SUPP_RESULT_SUCCESS ||
 309             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X))
 310                 return;
 311
 312         if (!wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt))
 313                 return;
 314
 315         wpa_printf(MSG_DEBUG, "Configure PMK for driver-based RSN 4-way "
 316                    "handshake");
 317
 318         pmk_len = PMK_LEN;
 319         if (wpa_key_mgmt_ft(wpa_s->key_mgmt)) {
 320 #ifdef CONFIG_IEEE80211R
 321                 u8 buf[2 * PMK_LEN];
 322                 wpa_printf(MSG_DEBUG, "RSN: Use FT XXKey as PMK for "
 323                            "driver-based 4-way hs and FT");
 324                 res = eapol_sm_get_key(eapol, buf, 2 * PMK_LEN);
 325                 if (res == 0) {
 326                         os_memcpy(pmk, buf + PMK_LEN, PMK_LEN);
 327                         os_memset(buf, 0, sizeof(buf));
 328                 }
 329 #else /* CONFIG_IEEE80211R */
 330                 res = -1;
 331 #endif /* CONFIG_IEEE80211R */
 332         } else {
 333                 res = eapol_sm_get_key(eapol, pmk, PMK_LEN);
 334                 if (res) {
 335                         /*
 336                          * EAP-LEAP is an exception from other EAP methods: it
 337                          * uses only 16-byte PMK.
 338                          */
 339                         res = eapol_sm_get_key(eapol, pmk, 16);
 340                         pmk_len = 16;
 341                 }
 342         }
 343
 344         if (res) {
 345                 wpa_printf(MSG_DEBUG, "Failed to get PMK from EAPOL state "
 346                            "machines");
 347                 return;
 348         }
 349
 350         wpa_hexdump_key(MSG_DEBUG, "RSN: Configure PMK for driver-based 4-way "
 351                         "handshake", pmk, pmk_len);
 352
 353         if (wpa_drv_set_key(wpa_s, WPA_ALG_PMK, NULL, 0, 0, NULL, 0, pmk,
 354                             pmk_len, KEY_FLAG_PMK)) {
 355                 wpa_printf(MSG_DEBUG, "Failed to set PMK to the driver");
 356         }
 357
 358         wpa_supplicant_cancel_scan(wpa_s);
 359         wpa_supplicant_cancel_auth_timeout(wpa_s);
 360         wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
 361
 362 }
 363
 364
 365 static void wpa_supplicant_notify_eapol_done(void *ctx)
 366 {
 367         struct wpa_supplicant *wpa_s = ctx;
 368         wpa_msg(wpa_s, MSG_DEBUG, "WPA: EAPOL processing complete");
 369         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
 370                 wpa_supplicant_set_state(wpa_s, WPA_4WAY_HANDSHAKE);
 371         } else {
 372                 wpa_supplicant_cancel_auth_timeout(wpa_s);
 373                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
 374         }
 375 }
 376
 377 #endif /* IEEE8021X_EAPOL */
 378
 379
 380 #ifndef CONFIG_NO_WPA
 381
 382 static int wpa_get_beacon_ie(struct wpa_supplicant *wpa_s)
 383 {
 384         int ret = 0;
 385         struct wpa_bss *curr = NULL, *bss;
 386         struct wpa_ssid *ssid = wpa_s->current_ssid;
 387         const u8 *ie;
 388
 389         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
 390                 if (os_memcmp(bss->bssid, wpa_s->bssid, ETH_ALEN) != 0)
 391                         continue;
 392                 if (ssid == NULL ||
 393                     ((bss->ssid_len == ssid->ssid_len &&
 394                       os_memcmp(bss->ssid, ssid->ssid, ssid->ssid_len) == 0) ||
 395                      ssid->ssid_len == 0)) {
 396                         curr = bss;
 397                         break;
 398                 }
 399         }
 400
 401         if (curr) {
 402                 ie = wpa_bss_get_vendor_ie(curr, WPA_IE_VENDOR_TYPE);
 403                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0))
 404                         ret = -1;
 405
 406                 ie = wpa_bss_get_ie(curr, WLAN_EID_RSN);
 407                 if (wpa_sm_set_ap_rsn_ie(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0))
 408                         ret = -1;
 409
 410                 ie = wpa_bss_get_ie(curr, WLAN_EID_RSNX);
 411                 if (wpa_sm_set_ap_rsnxe(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0))
 412                         ret = -1;
 413         } else {
 414                 ret = -1;
 415         }
 416
 417         return ret;
 418 }
 419
 420
 421 static int wpa_supplicant_get_beacon_ie(void *ctx)
 422 {
 423         struct wpa_supplicant *wpa_s = ctx;
 424         if (wpa_get_beacon_ie(wpa_s) == 0) {
 425                 return 0;
 426         }
 427
 428         /* No WPA/RSN IE found in the cached scan results. Try to get updated
 429          * scan results from the driver. */
 430         if (wpa_supplicant_update_scan_results(wpa_s) < 0)
 431                 return -1;
 432
 433         return wpa_get_beacon_ie(wpa_s);
 434 }
 435
 436
 437 static u8 * _wpa_alloc_eapol(void *wpa_s, u8 type,
 438                              const void *data, u16 data_len,
 439                              size_t *msg_len, void **data_pos)
 440 {
 441         return wpa_alloc_eapol(wpa_s, type, data, data_len, msg_len, data_pos);
 442 }
 443
 444
 445 static int _wpa_ether_send(void *wpa_s, const u8 *dest, u16 proto,
 446                            const u8 *buf, size_t len)
 447 {
 448         return wpa_ether_send(wpa_s, dest, proto, buf, len);
 449 }
 450
 451
 452 static void _wpa_supplicant_cancel_auth_timeout(void *wpa_s)
 453 {
 454         wpa_supplicant_cancel_auth_timeout(wpa_s);
 455 }
 456
 457
 458 static void _wpa_supplicant_set_state(void *wpa_s, enum wpa_states state)
 459 {
 460         wpa_supplicant_set_state(wpa_s, state);
 461 }
 462
 463
 464 /**
 465  * wpa_supplicant_get_state - Get the connection state
 466  * @wpa_s: Pointer to wpa_supplicant data
 467  * Returns: The current connection state (WPA_*)
 468  */
 469 static enum wpa_states wpa_supplicant_get_state(struct wpa_supplicant *wpa_s)
 470 {
 471         return wpa_s->wpa_state;
 472 }
 473
 474
 475 static enum wpa_states _wpa_supplicant_get_state(void *wpa_s)
 476 {
 477         return wpa_supplicant_get_state(wpa_s);
 478 }
 479
 480
 481 static void _wpa_supplicant_deauthenticate(void *wpa_s, u16 reason_code)
 482 {
 483         wpa_supplicant_deauthenticate(wpa_s, reason_code);
 484         /* Schedule a scan to make sure we continue looking for networks */
 485         wpa_supplicant_req_scan(wpa_s, 5, 0);
 486 }
 487
 488
 489 static void _wpa_supplicant_reconnect(void *wpa_s)
 490 {
 491         wpa_supplicant_reconnect(wpa_s);
 492 }
 493
 494
 495 static void * wpa_supplicant_get_network_ctx(void *wpa_s)
 496 {
 497         return wpa_supplicant_get_ssid(wpa_s);
 498 }
 499
 500
 501 static int wpa_supplicant_get_bssid(void *ctx, u8 *bssid)
 502 {
 503         struct wpa_supplicant *wpa_s = ctx;
 504         return wpa_drv_get_bssid(wpa_s, bssid);
 505 }
 506
 507
 508 static int wpa_supplicant_set_key(void *_wpa_s, enum wpa_alg alg,
 509                                   const u8 *addr, int key_idx, int set_tx,
 510                                   const u8 *seq, size_t seq_len,
 511                                   const u8 *key, size_t key_len,
 512                                   enum key_flag key_flag)
 513 {
 514         struct wpa_supplicant *wpa_s = _wpa_s;
 515         if (alg == WPA_ALG_TKIP && key_idx == 0 && key_len == 32) {
 516                 /* Clear the MIC error counter when setting a new PTK. */
 517                 wpa_s->mic_errors_seen = 0;
 518         }
 519 #ifdef CONFIG_TESTING_GET_GTK
 520         if (key_idx > 0 && addr && is_broadcast_ether_addr(addr) &&
 521             alg != WPA_ALG_NONE && key_len <= sizeof(wpa_s->last_gtk)) {
 522                 os_memcpy(wpa_s->last_gtk, key, key_len);
 523                 wpa_s->last_gtk_len = key_len;
 524         }
 525 #endif /* CONFIG_TESTING_GET_GTK */
 526 #ifdef CONFIG_TESTING_OPTIONS
 527         if (addr && !is_broadcast_ether_addr(addr)) {
 528                 wpa_s->last_tk_alg = alg;
 529                 os_memcpy(wpa_s->last_tk_addr, addr, ETH_ALEN);
 530                 wpa_s->last_tk_key_idx = key_idx;
 531                 if (key)
 532                         os_memcpy(wpa_s->last_tk, key, key_len);
 533                 wpa_s->last_tk_len = key_len;
 534         }
 535 #endif /* CONFIG_TESTING_OPTIONS */
 536         return wpa_drv_set_key(wpa_s, alg, addr, key_idx, set_tx, seq, seq_len,
 537                                key, key_len, key_flag);
 538 }
 539
 540
 541 static int wpa_supplicant_mlme_setprotection(void *wpa_s, const u8 *addr,
 542                                              int protection_type,
 543                                              int key_type)
 544 {
 545         return wpa_drv_mlme_setprotection(wpa_s, addr, protection_type,
 546                                           key_type);
 547 }
 548
 549
 550 static struct wpa_ssid * wpas_get_network_ctx(struct wpa_supplicant *wpa_s,
 551                                               void *network_ctx)
 552 {
 553         struct wpa_ssid *ssid;
 554
 555         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
 556                 if (network_ctx == ssid)
 557                         return ssid;
 558         }
 559
 560         return NULL;
 561 }
 562
 563
 564 static int wpa_supplicant_add_pmkid(void *_wpa_s, void *network_ctx,
 565                                     const u8 *bssid, const u8 *pmkid,
 566                                     const u8 *fils_cache_id,
 567                                     const u8 *pmk, size_t pmk_len)
 568 {
 569         struct wpa_supplicant *wpa_s = _wpa_s;
 570         struct wpa_ssid *ssid;
 571         struct wpa_pmkid_params params;
 572
 573         os_memset(&params, 0, sizeof(params));
 574         ssid = wpas_get_network_ctx(wpa_s, network_ctx);
 575         if (ssid)
 576                 wpa_msg(wpa_s, MSG_INFO, PMKSA_CACHE_ADDED MACSTR " %d",
 577                         MAC2STR(bssid), ssid->id);
 578         if (ssid && fils_cache_id) {
 579                 params.ssid = ssid->ssid;
 580                 params.ssid_len = ssid->ssid_len;
 581                 params.fils_cache_id = fils_cache_id;
 582         } else {
 583                 params.bssid = bssid;
 584         }
 585
 586         params.pmkid = pmkid;
 587         params.pmk = pmk;
 588         params.pmk_len = pmk_len;
 589
 590         return wpa_drv_add_pmkid(wpa_s, &params);
 591 }
 592
 593
 594 static int wpa_supplicant_remove_pmkid(void *_wpa_s, void *network_ctx,
 595                                        const u8 *bssid, const u8 *pmkid,
 596                                        const u8 *fils_cache_id)
 597 {
 598         struct wpa_supplicant *wpa_s = _wpa_s;
 599         struct wpa_ssid *ssid;
 600         struct wpa_pmkid_params params;
 601
 602         os_memset(&params, 0, sizeof(params));
 603         ssid = wpas_get_network_ctx(wpa_s, network_ctx);
 604         if (ssid)
 605                 wpa_msg(wpa_s, MSG_INFO, PMKSA_CACHE_REMOVED MACSTR " %d",
 606                         MAC2STR(bssid), ssid->id);
 607         if (ssid && fils_cache_id) {
 608                 params.ssid = ssid->ssid;
 609                 params.ssid_len = ssid->ssid_len;
 610                 params.fils_cache_id = fils_cache_id;
 611         } else {
 612                 params.bssid = bssid;
 613         }
 614
 615         params.pmkid = pmkid;
 616
 617         return wpa_drv_remove_pmkid(wpa_s, &params);
 618 }
 619
 620
 621 #ifdef CONFIG_IEEE80211R
 622 static int wpa_supplicant_update_ft_ies(void *ctx, const u8 *md,
 623                                         const u8 *ies, size_t ies_len)
 624 {
 625         struct wpa_supplicant *wpa_s = ctx;
 626         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
 627                 return sme_update_ft_ies(wpa_s, md, ies, ies_len);
 628         return wpa_drv_update_ft_ies(wpa_s, md, ies, ies_len);
 629 }
 630
 631
 632 static int wpa_supplicant_send_ft_action(void *ctx, u8 action,
 633                                          const u8 *target_ap,
 634                                          const u8 *ies, size_t ies_len)
 635 {
 636         struct wpa_supplicant *wpa_s = ctx;
 637         int ret;
 638         u8 *data, *pos;
 639         size_t data_len;
 640
 641         if (action != 1) {
 642                 wpa_printf(MSG_ERROR, "Unsupported send_ft_action action %d",
 643                            action);
 644                 return -1;
 645         }
 646
 647         /*
 648          * Action frame payload:
 649          * Category[1] = 6 (Fast BSS Transition)
 650          * Action[1] = 1 (Fast BSS Transition Request)
 651          * STA Address
 652          * Target AP Address
 653          * FT IEs
 654          */
 655
 656         data_len = 2 + 2 * ETH_ALEN + ies_len;
 657         data = os_malloc(data_len);
 658         if (data == NULL)
 659                 return -1;
 660         pos = data;
 661         *pos++ = 0x06; /* FT Action category */
 662         *pos++ = action;
 663         os_memcpy(pos, wpa_s->own_addr, ETH_ALEN);
 664         pos += ETH_ALEN;
 665         os_memcpy(pos, target_ap, ETH_ALEN);
 666         pos += ETH_ALEN;
 667         os_memcpy(pos, ies, ies_len);
 668
 669         ret = wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0,
 670                                   wpa_s->bssid, wpa_s->own_addr, wpa_s->bssid,
 671                                   data, data_len, 0);
 672         os_free(data);
 673
 674         return ret;
 675 }
 676
 677
 678 static int wpa_supplicant_mark_authenticated(void *ctx, const u8 *target_ap)
 679 {
 680         struct wpa_supplicant *wpa_s = ctx;
 681         struct wpa_driver_auth_params params;
 682         struct wpa_bss *bss;
 683
 684         bss = wpa_bss_get_bssid(wpa_s, target_ap);
 685         if (bss == NULL)
 686                 return -1;
 687
 688         os_memset(&params, 0, sizeof(params));
 689         params.bssid = target_ap;
 690         params.freq = bss->freq;
 691         params.ssid = bss->ssid;
 692         params.ssid_len = bss->ssid_len;
 693         params.auth_alg = WPA_AUTH_ALG_FT;
 694         params.local_state_change = 1;
 695         return wpa_drv_authenticate(wpa_s, &params);
 696 }
 697 #endif /* CONFIG_IEEE80211R */
 698
 699
 700 #ifdef CONFIG_TDLS
 701
 702 static int wpa_supplicant_tdls_get_capa(void *ctx, int *tdls_supported,
 703                                         int *tdls_ext_setup,
 704                                         int *tdls_chan_switch)
 705 {
 706         struct wpa_supplicant *wpa_s = ctx;
 707
 708         *tdls_supported = 0;
 709         *tdls_ext_setup = 0;
 710         *tdls_chan_switch = 0;
 711
 712         if (!wpa_s->drv_capa_known)
 713                 return -1;
 714
 715         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT)
 716                 *tdls_supported = 1;
 717
 718         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP)
 719                 *tdls_ext_setup = 1;
 720
 721         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH)
 722                 *tdls_chan_switch = 1;
 723
 724         return 0;
 725 }
 726
 727
 728 static int wpa_supplicant_send_tdls_mgmt(void *ctx, const u8 *dst,
 729                                          u8 action_code, u8 dialog_token,
 730                                          u16 status_code, u32 peer_capab,
 731                                          int initiator, const u8 *buf,
 732                                          size_t len)
 733 {
 734         struct wpa_supplicant *wpa_s = ctx;
 735         return wpa_drv_send_tdls_mgmt(wpa_s, dst, action_code, dialog_token,
 736                                       status_code, peer_capab, initiator, buf,
 737                                       len);
 738 }
 739
 740
 741 static int wpa_supplicant_tdls_oper(void *ctx, int oper, const u8 *peer)
 742 {
 743         struct wpa_supplicant *wpa_s = ctx;
 744         return wpa_drv_tdls_oper(wpa_s, oper, peer);
 745 }
 746
 747
 748 static int wpa_supplicant_tdls_peer_addset(
 749         void *ctx, const u8 *peer, int add, u16 aid, u16 capability,
 750         const u8 *supp_rates, size_t supp_rates_len,
 751         const struct ieee80211_ht_capabilities *ht_capab,
 752         const struct ieee80211_vht_capabilities *vht_capab,
 753         u8 qosinfo, int wmm, const u8 *ext_capab, size_t ext_capab_len,
 754         const u8 *supp_channels, size_t supp_channels_len,
 755         const u8 *supp_oper_classes, size_t supp_oper_classes_len)
 756 {
 757         struct wpa_supplicant *wpa_s = ctx;
 758         struct hostapd_sta_add_params params;
 759
 760         os_memset(&params, 0, sizeof(params));
 761
 762         params.addr = peer;
 763         params.aid = aid;
 764         params.capability = capability;
 765         params.flags = WPA_STA_TDLS_PEER | WPA_STA_AUTHORIZED;
 766
 767         /*
 768          * Don't rely only on qosinfo for WMM capability. It may be 0 even when
 769          * present. Allow the WMM IE to also indicate QoS support.
 770          */
 771         if (wmm || qosinfo)
 772                 params.flags |= WPA_STA_WMM;
 773
 774         params.ht_capabilities = ht_capab;
 775         params.vht_capabilities = vht_capab;
 776         params.qosinfo = qosinfo;
 777         params.listen_interval = 0;
 778         params.supp_rates = supp_rates;
 779         params.supp_rates_len = supp_rates_len;
 780         params.set = !add;
 781         params.ext_capab = ext_capab;
 782         params.ext_capab_len = ext_capab_len;
 783         params.supp_channels = supp_channels;
 784         params.supp_channels_len = supp_channels_len;
 785         params.supp_oper_classes = supp_oper_classes;
 786         params.supp_oper_classes_len = supp_oper_classes_len;
 787
 788         return wpa_drv_sta_add(wpa_s, &params);
 789 }
 790
 791
 792 static int wpa_supplicant_tdls_enable_channel_switch(
 793         void *ctx, const u8 *addr, u8 oper_class,
 794         const struct hostapd_freq_params *params)
 795 {
 796         struct wpa_supplicant *wpa_s = ctx;
 797
 798         return wpa_drv_tdls_enable_channel_switch(wpa_s, addr, oper_class,
 799                                                   params);
 800 }
 801
 802
 803 static int wpa_supplicant_tdls_disable_channel_switch(void *ctx, const u8 *addr)
 804 {
 805         struct wpa_supplicant *wpa_s = ctx;
 806
 807         return wpa_drv_tdls_disable_channel_switch(wpa_s, addr);
 808 }
 809
 810 #endif /* CONFIG_TDLS */
 811
 812 #endif /* CONFIG_NO_WPA */
 813
 814
 815 enum wpa_ctrl_req_type wpa_supplicant_ctrl_req_from_string(const char *field)
 816 {
 817         if (os_strcmp(field, "IDENTITY") == 0)
 818                 return WPA_CTRL_REQ_EAP_IDENTITY;
 819         else if (os_strcmp(field, "PASSWORD") == 0)
 820                 return WPA_CTRL_REQ_EAP_PASSWORD;
 821         else if (os_strcmp(field, "NEW_PASSWORD") == 0)
 822                 return WPA_CTRL_REQ_EAP_NEW_PASSWORD;
 823         else if (os_strcmp(field, "PIN") == 0)
 824                 return WPA_CTRL_REQ_EAP_PIN;
 825         else if (os_strcmp(field, "OTP") == 0)
 826                 return WPA_CTRL_REQ_EAP_OTP;
 827         else if (os_strcmp(field, "PASSPHRASE") == 0)
 828                 return WPA_CTRL_REQ_EAP_PASSPHRASE;
 829         else if (os_strcmp(field, "SIM") == 0)
 830                 return WPA_CTRL_REQ_SIM;
 831         else if (os_strcmp(field, "PSK_PASSPHRASE") == 0)
 832                 return WPA_CTRL_REQ_PSK_PASSPHRASE;
 833         else if (os_strcmp(field, "EXT_CERT_CHECK") == 0)
 834                 return WPA_CTRL_REQ_EXT_CERT_CHECK;
 835         return WPA_CTRL_REQ_UNKNOWN;
 836 }
 837
 838
 839 const char * wpa_supplicant_ctrl_req_to_string(enum wpa_ctrl_req_type field,
 840                                                const char *default_txt,
 841                                                const char **txt)
 842 {
 843         const char *ret = NULL;
 844
 845         *txt = default_txt;
 846
 847         switch (field) {
 848         case WPA_CTRL_REQ_EAP_IDENTITY:
 849                 *txt = "Identity";
 850                 ret = "IDENTITY";
 851                 break;
 852         case WPA_CTRL_REQ_EAP_PASSWORD:
 853                 *txt = "Password";
 854                 ret = "PASSWORD";
 855                 break;
 856         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
 857                 *txt = "New Password";
 858                 ret = "NEW_PASSWORD";
 859                 break;
 860         case WPA_CTRL_REQ_EAP_PIN:
 861                 *txt = "PIN";
 862                 ret = "PIN";
 863                 break;
 864         case WPA_CTRL_REQ_EAP_OTP:
 865                 ret = "OTP";
 866                 break;
 867         case WPA_CTRL_REQ_EAP_PASSPHRASE:
 868                 *txt = "Private key passphrase";
 869                 ret = "PASSPHRASE";
 870                 break;
 871         case WPA_CTRL_REQ_SIM:
 872                 ret = "SIM";
 873                 break;
 874         case WPA_CTRL_REQ_PSK_PASSPHRASE:
 875                 *txt = "PSK or passphrase";
 876                 ret = "PSK_PASSPHRASE";
 877                 break;
 878         case WPA_CTRL_REQ_EXT_CERT_CHECK:
 879                 *txt = "External server certificate validation";
 880                 ret = "EXT_CERT_CHECK";
 881                 break;
 882         default:
 883                 break;
 884         }
 885
 886         /* txt needs to be something */
 887         if (*txt == NULL) {
 888                 wpa_printf(MSG_WARNING, "No message for request %d", field);
 889                 ret = NULL;
 890         }
 891
 892         return ret;
 893 }
 894
 895
 896 void wpas_send_ctrl_req(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
 897                         const char *field_name, const char *txt)
 898 {
 899         char *buf;
 900         size_t buflen;
 901         int len;
 902
 903         buflen = 100 + os_strlen(txt) + ssid->ssid_len;
 904         buf = os_malloc(buflen);
 905         if (buf == NULL)
 906                 return;
 907         len = os_snprintf(buf, buflen, "%s-%d:%s needed for SSID ",
 908                           field_name, ssid->id, txt);
 909         if (os_snprintf_error(buflen, len)) {
 910                 os_free(buf);
 911                 return;
 912         }
 913         if (ssid->ssid && buflen > len + ssid->ssid_len) {
 914                 os_memcpy(buf + len, ssid->ssid, ssid->ssid_len);
 915                 len += ssid->ssid_len;
 916                 buf[len] = '\0';
 917         }
 918         buf[buflen - 1] = '\0';
 919         wpa_msg(wpa_s, MSG_INFO, WPA_CTRL_REQ "%s", buf);
 920         os_free(buf);
 921 }
 922
 923
 924 #ifdef IEEE8021X_EAPOL
 925 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 926 static void wpa_supplicant_eap_param_needed(void *ctx,
 927                                             enum wpa_ctrl_req_type field,
 928                                             const char *default_txt)
 929 {
 930         struct wpa_supplicant *wpa_s = ctx;
 931         struct wpa_ssid *ssid = wpa_s->current_ssid;
 932         const char *field_name, *txt = NULL;
 933
 934         if (ssid == NULL)
 935                 return;
 936
 937         if (field == WPA_CTRL_REQ_EXT_CERT_CHECK)
 938                 ssid->eap.pending_ext_cert_check = PENDING_CHECK;
 939         wpas_notify_network_request(wpa_s, ssid, field, default_txt);
 940
 941         field_name = wpa_supplicant_ctrl_req_to_string(field, default_txt,
 942                                                        &txt);
 943         if (field_name == NULL) {
 944                 wpa_printf(MSG_WARNING, "Unhandled EAP param %d needed",
 945                            field);
 946                 return;
 947         }
 948
 949         wpas_notify_eap_status(wpa_s, "eap parameter needed", field_name);
 950
 951         wpas_send_ctrl_req(wpa_s, ssid, field_name, txt);
 952 }
 953 #else /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 954 #define wpa_supplicant_eap_param_needed NULL
 955 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 956
 957
 958 #ifdef CONFIG_EAP_PROXY
 959
 960 static void wpa_supplicant_eap_proxy_cb(void *ctx)
 961 {
 962         struct wpa_supplicant *wpa_s = ctx;
 963         size_t len;
 964
 965         wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, -1,
 966                                                      wpa_s->imsi, &len);
 967         if (wpa_s->mnc_len > 0) {
 968                 wpa_s->imsi[len] = '\0';
 969                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
 970                            wpa_s->imsi, wpa_s->mnc_len);
 971         } else {
 972                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
 973         }
 974 }
 975
 976
 977 static void wpa_sm_sim_state_error_handler(struct wpa_supplicant *wpa_s)
 978 {
 979         int i;
 980         struct wpa_ssid *ssid;
 981         const struct eap_method_type *eap_methods;
 982
 983         if (!wpa_s->conf)
 984                 return;
 985
 986         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
 987                 eap_methods = ssid->eap.eap_methods;
 988                 if (!eap_methods)
 989                         continue;
 990
 991                 for (i = 0; eap_methods[i].method != EAP_TYPE_NONE; i++) {
 992                         if (eap_methods[i].vendor == EAP_VENDOR_IETF &&
 993                             (eap_methods[i].method == EAP_TYPE_SIM ||
 994                              eap_methods[i].method == EAP_TYPE_AKA ||
 995                              eap_methods[i].method == EAP_TYPE_AKA_PRIME)) {
 996                                 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
 997                                 break;
 998                         }
 999                 }
1000         }
1001 }
1002
1003
1004 static void
1005 wpa_supplicant_eap_proxy_notify_sim_status(void *ctx,
1006                                            enum eap_proxy_sim_state sim_state)
1007 {
1008         struct wpa_supplicant *wpa_s = ctx;
1009
1010         wpa_printf(MSG_DEBUG, "eap_proxy: SIM card status %u", sim_state);
1011         switch (sim_state) {
1012         case SIM_STATE_ERROR:
1013                 wpa_sm_sim_state_error_handler(wpa_s);
1014                 break;
1015         default:
1016                 wpa_printf(MSG_DEBUG, "eap_proxy: SIM card status unknown");
1017                 break;
1018         }
1019 }
1020
1021 #endif /* CONFIG_EAP_PROXY */
1022
1023
1024 static void wpa_supplicant_port_cb(void *ctx, int authorized)
1025 {
1026         struct wpa_supplicant *wpa_s = ctx;
1027 #ifdef CONFIG_AP
1028         if (wpa_s->ap_iface) {
1029                 wpa_printf(MSG_DEBUG, "AP mode active - skip EAPOL Supplicant "
1030                            "port status: %s",
1031                            authorized ? "Authorized" : "Unauthorized");
1032                 return;
1033         }
1034 #endif /* CONFIG_AP */
1035         wpa_printf(MSG_DEBUG, "EAPOL: Supplicant port status: %s",
1036                    authorized ? "Authorized" : "Unauthorized");
1037         wpa_drv_set_supp_port(wpa_s, authorized);
1038 }
1039
1040
1041 static void wpa_supplicant_cert_cb(void *ctx, struct tls_cert_data *cert,
1042                                    const char *cert_hash)
1043 {
1044         struct wpa_supplicant *wpa_s = ctx;
1045
1046         wpas_notify_certification(wpa_s, cert, cert_hash);
1047 }
1048
1049
1050 static void wpa_supplicant_status_cb(void *ctx, const char *status,
1051                                      const char *parameter)
1052 {
1053         struct wpa_supplicant *wpa_s = ctx;
1054
1055         wpas_notify_eap_status(wpa_s, status, parameter);
1056 }
1057
1058
1059 static void wpa_supplicant_eap_error_cb(void *ctx, int error_code)
1060 {
1061         struct wpa_supplicant *wpa_s = ctx;
1062
1063         wpas_notify_eap_error(wpa_s, error_code);
1064 }
1065
1066
1067 static int wpa_supplicant_eap_auth_start_cb(void *ctx)
1068 {
1069         struct wpa_supplicant *wpa_s = ctx;
1070
1071         if (!wpa_s->new_connection && wpa_s->deny_ptk0_rekey) {
1072                 wpa_msg(wpa_s, MSG_INFO,
1073                         "WPA: PTK0 rekey not allowed, reconnecting");
1074                 wpa_supplicant_reconnect(wpa_s);
1075                 return -1;
1076         }
1077         return 0;
1078 }
1079
1080
1081 static void wpa_supplicant_set_anon_id(void *ctx, const u8 *id, size_t len)
1082 {
1083         struct wpa_supplicant *wpa_s = ctx;
1084         char *str;
1085         int res;
1086
1087         wpa_hexdump_ascii(MSG_DEBUG, "EAP method updated anonymous_identity",
1088                           id, len);
1089
1090         if (wpa_s->current_ssid == NULL)
1091                 return;
1092
1093         if (id == NULL) {
1094                 if (wpa_config_set(wpa_s->current_ssid, "anonymous_identity",
1095                                    "NULL", 0) < 0)
1096                         return;
1097         } else {
1098                 str = os_malloc(len * 2 + 1);
1099                 if (str == NULL)
1100                         return;
1101                 wpa_snprintf_hex(str, len * 2 + 1, id, len);
1102                 res = wpa_config_set(wpa_s->current_ssid, "anonymous_identity",
1103                                      str, 0);
1104                 os_free(str);
1105                 if (res < 0)
1106                         return;
1107         }
1108
1109         if (wpa_s->conf->update_config) {
1110                 res = wpa_config_write(wpa_s->confname, wpa_s->conf);
1111                 if (res) {
1112                         wpa_printf(MSG_DEBUG, "Failed to update config after "
1113                                    "anonymous_id update");
1114                 }
1115         }
1116 }
1117 #endif /* IEEE8021X_EAPOL */
1118
1119
1120 int wpa_supplicant_init_eapol(struct wpa_supplicant *wpa_s)
1121 {
1122 #ifdef IEEE8021X_EAPOL
1123         struct eapol_ctx *ctx;
1124         ctx = os_zalloc(sizeof(*ctx));
1125         if (ctx == NULL) {
1126                 wpa_printf(MSG_ERROR, "Failed to allocate EAPOL context.");
1127                 return -1;
1128         }
1129
1130         ctx->ctx = wpa_s;
1131         ctx->msg_ctx = wpa_s;
1132         ctx->eapol_send_ctx = wpa_s;
1133         ctx->preauth = 0;
1134         ctx->eapol_done_cb = wpa_supplicant_notify_eapol_done;
1135         ctx->eapol_send = wpa_supplicant_eapol_send;
1136         ctx->set_wep_key = wpa_eapol_set_wep_key;
1137 #ifndef CONFIG_NO_CONFIG_BLOBS
1138         ctx->set_config_blob = wpa_supplicant_set_config_blob;
1139         ctx->get_config_blob = wpa_supplicant_get_config_blob;
1140 #endif /* CONFIG_NO_CONFIG_BLOBS */
1141         ctx->aborted_cached = wpa_supplicant_aborted_cached;
1142         ctx->opensc_engine_path = wpa_s->conf->opensc_engine_path;
1143         ctx->pkcs11_engine_path = wpa_s->conf->pkcs11_engine_path;
1144         ctx->pkcs11_module_path = wpa_s->conf->pkcs11_module_path;
1145         ctx->openssl_ciphers = wpa_s->conf->openssl_ciphers;
1146         ctx->wps = wpa_s->wps;
1147         ctx->eap_param_needed = wpa_supplicant_eap_param_needed;
1148 #ifdef CONFIG_EAP_PROXY
1149         ctx->eap_proxy_cb = wpa_supplicant_eap_proxy_cb;
1150         ctx->eap_proxy_notify_sim_status =
1151                 wpa_supplicant_eap_proxy_notify_sim_status;
1152 #endif /* CONFIG_EAP_PROXY */
1153         ctx->port_cb = wpa_supplicant_port_cb;
1154         ctx->cb = wpa_supplicant_eapol_cb;
1155         ctx->cert_cb = wpa_supplicant_cert_cb;
1156         ctx->cert_in_cb = wpa_s->conf->cert_in_cb;
1157         ctx->status_cb = wpa_supplicant_status_cb;
1158         ctx->eap_error_cb = wpa_supplicant_eap_error_cb;
1159         ctx->confirm_auth_cb = wpa_supplicant_eap_auth_start_cb;
1160         ctx->set_anon_id = wpa_supplicant_set_anon_id;
1161         ctx->cb_ctx = wpa_s;
1162         wpa_s->eapol = eapol_sm_init(ctx);
1163         if (wpa_s->eapol == NULL) {
1164                 os_free(ctx);
1165                 wpa_printf(MSG_ERROR, "Failed to initialize EAPOL state "
1166                            "machines.");
1167                 return -1;
1168         }
1169 #endif /* IEEE8021X_EAPOL */
1170
1171         return 0;
1172 }
1173
1174
1175 #ifndef CONFIG_NO_WPA
1176
1177 static void wpa_supplicant_set_rekey_offload(void *ctx,
1178                                              const u8 *kek, size_t kek_len,
1179                                              const u8 *kck, size_t kck_len,
1180                                              const u8 *replay_ctr)
1181 {
1182         struct wpa_supplicant *wpa_s = ctx;
1183
1184         wpa_drv_set_rekey_info(wpa_s, kek, kek_len, kck, kck_len, replay_ctr);
1185 }
1186
1187
1188 static int wpa_supplicant_key_mgmt_set_pmk(void *ctx, const u8 *pmk,
1189                                            size_t pmk_len)
1190 {
1191         struct wpa_supplicant *wpa_s = ctx;
1192
1193         if (wpa_s->conf->key_mgmt_offload &&
1194             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD))
1195                 return wpa_drv_set_key(wpa_s, WPA_ALG_PMK, NULL, 0, 0,
1196                                        NULL, 0, pmk, pmk_len, KEY_FLAG_PMK);
1197         else
1198                 return 0;
1199 }
1200
1201
1202 static void wpa_supplicant_fils_hlp_rx(void *ctx, const u8 *dst, const u8 *src,
1203                                        const u8 *pkt, size_t pkt_len)
1204 {
1205         struct wpa_supplicant *wpa_s = ctx;
1206         char *hex;
1207         size_t hexlen;
1208
1209         hexlen = pkt_len * 2 + 1;
1210         hex = os_malloc(hexlen);
1211         if (!hex)
1212                 return;
1213         wpa_snprintf_hex(hex, hexlen, pkt, pkt_len);
1214         wpa_msg(wpa_s, MSG_INFO, FILS_HLP_RX "dst=" MACSTR " src=" MACSTR
1215                 " frame=%s", MAC2STR(dst), MAC2STR(src), hex);
1216         os_free(hex);
1217 }
1218
1219
1220 static int wpa_supplicant_channel_info(void *_wpa_s,
1221                                        struct wpa_channel_info *ci)
1222 {
1223         struct wpa_supplicant *wpa_s = _wpa_s;
1224
1225         return wpa_drv_channel_info(wpa_s, ci);
1226 }
1227
1228 #endif /* CONFIG_NO_WPA */
1229
1230
1231 int wpa_supplicant_init_wpa(struct wpa_supplicant *wpa_s)
1232 {
1233 #ifndef CONFIG_NO_WPA
1234         struct wpa_sm_ctx *ctx;
1235         ctx = os_zalloc(sizeof(*ctx));
1236         if (ctx == NULL) {
1237                 wpa_printf(MSG_ERROR, "Failed to allocate WPA context.");
1238                 return -1;
1239         }
1240
1241         ctx->ctx = wpa_s;
1242         ctx->msg_ctx = wpa_s;
1243         ctx->set_state = _wpa_supplicant_set_state;
1244         ctx->get_state = _wpa_supplicant_get_state;
1245         ctx->deauthenticate = _wpa_supplicant_deauthenticate;
1246         ctx->reconnect = _wpa_supplicant_reconnect;
1247         ctx->set_key = wpa_supplicant_set_key;
1248         ctx->get_network_ctx = wpa_supplicant_get_network_ctx;
1249         ctx->get_bssid = wpa_supplicant_get_bssid;
1250         ctx->ether_send = _wpa_ether_send;
1251         ctx->get_beacon_ie = wpa_supplicant_get_beacon_ie;
1252         ctx->alloc_eapol = _wpa_alloc_eapol;
1253         ctx->cancel_auth_timeout = _wpa_supplicant_cancel_auth_timeout;
1254         ctx->add_pmkid = wpa_supplicant_add_pmkid;
1255         ctx->remove_pmkid = wpa_supplicant_remove_pmkid;
1256 #ifndef CONFIG_NO_CONFIG_BLOBS
1257         ctx->set_config_blob = wpa_supplicant_set_config_blob;
1258         ctx->get_config_blob = wpa_supplicant_get_config_blob;
1259 #endif /* CONFIG_NO_CONFIG_BLOBS */
1260         ctx->mlme_setprotection = wpa_supplicant_mlme_setprotection;
1261 #ifdef CONFIG_IEEE80211R
1262         ctx->update_ft_ies = wpa_supplicant_update_ft_ies;
1263         ctx->send_ft_action = wpa_supplicant_send_ft_action;
1264         ctx->mark_authenticated = wpa_supplicant_mark_authenticated;
1265 #endif /* CONFIG_IEEE80211R */
1266 #ifdef CONFIG_TDLS
1267         ctx->tdls_get_capa = wpa_supplicant_tdls_get_capa;
1268         ctx->send_tdls_mgmt = wpa_supplicant_send_tdls_mgmt;
1269         ctx->tdls_oper = wpa_supplicant_tdls_oper;
1270         ctx->tdls_peer_addset = wpa_supplicant_tdls_peer_addset;
1271         ctx->tdls_enable_channel_switch =
1272                 wpa_supplicant_tdls_enable_channel_switch;
1273         ctx->tdls_disable_channel_switch =
1274                 wpa_supplicant_tdls_disable_channel_switch;
1275 #endif /* CONFIG_TDLS */
1276         ctx->set_rekey_offload = wpa_supplicant_set_rekey_offload;
1277         ctx->key_mgmt_set_pmk = wpa_supplicant_key_mgmt_set_pmk;
1278         ctx->fils_hlp_rx = wpa_supplicant_fils_hlp_rx;
1279         ctx->channel_info = wpa_supplicant_channel_info;
1280
1281         wpa_s->wpa = wpa_sm_init(ctx);
1282         if (wpa_s->wpa == NULL) {
1283                 wpa_printf(MSG_ERROR, "Failed to initialize WPA state "
1284                            "machine");
1285                 os_free(ctx);
1286                 return -1;
1287         }
1288 #endif /* CONFIG_NO_WPA */
1289
1290         return 0;
1291 }
1292
1293
1294 void wpa_supplicant_rsn_supp_set_config(struct wpa_supplicant *wpa_s,
1295                                         struct wpa_ssid *ssid)
1296 {
1297         struct rsn_supp_config conf;
1298         if (ssid) {
1299                 os_memset(&conf, 0, sizeof(conf));
1300                 conf.network_ctx = ssid;
1301                 conf.allowed_pairwise_cipher = ssid->pairwise_cipher;
1302 #ifdef IEEE8021X_EAPOL
1303                 conf.proactive_key_caching = ssid->proactive_key_caching < 0 ?
1304                         wpa_s->conf->okc : ssid->proactive_key_caching;
1305                 conf.eap_workaround = ssid->eap_workaround;
1306                 conf.eap_conf_ctx = &ssid->eap;
1307 #endif /* IEEE8021X_EAPOL */
1308                 conf.ssid = ssid->ssid;
1309                 conf.ssid_len = ssid->ssid_len;
1310                 conf.wpa_ptk_rekey = ssid->wpa_ptk_rekey;
1311                 conf.wpa_deny_ptk0_rekey = ssid->wpa_deny_ptk0_rekey;
1312                 conf.owe_ptk_workaround = ssid->owe_ptk_workaround;
1313 #ifdef CONFIG_P2P
1314                 if (ssid->p2p_group && wpa_s->current_bss &&
1315                     !wpa_s->p2p_disable_ip_addr_req) {
1316                         struct wpabuf *p2p;
1317                         p2p = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
1318                                                           P2P_IE_VENDOR_TYPE);
1319                         if (p2p) {
1320                                 u8 group_capab;
1321                                 group_capab = p2p_get_group_capab(p2p);
1322                                 if (group_capab &
1323                                     P2P_GROUP_CAPAB_IP_ADDR_ALLOCATION)
1324                                         conf.p2p = 1;
1325                                 wpabuf_free(p2p);
1326                         }
1327                 }
1328 #endif /* CONFIG_P2P */
1329                 conf.wpa_rsc_relaxation = wpa_s->conf->wpa_rsc_relaxation;
1330 #ifdef CONFIG_FILS
1331                 if (wpa_key_mgmt_fils(wpa_s->key_mgmt))
1332                         conf.fils_cache_id =
1333                                 wpa_bss_get_fils_cache_id(wpa_s->current_bss);
1334 #endif /* CONFIG_FILS */
1335                 conf.beacon_prot = ssid->beacon_prot;
1336         }
1337         wpa_sm_set_config(wpa_s->wpa, ssid ? &conf : NULL);
1338 }