LCOV - code coverage report
Current view: top level - wpa_supplicant - wpas_glue.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1422976643 Lines: 409 493 83.0 %
Date: 2015-02-03 Functions: 46 46 100.0 %

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

Generated by: LCOV version 1.10