wpa_supplicant/wpa_supplicant.c

   1 /*
   2  * WPA Supplicant
   3  * Copyright (c) 2003-2016, 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  * This file implements functions for registering and unregistering
   9  * %wpa_supplicant interfaces. In addition, this file contains number of
  10  * functions for managing network connections.
  11  */
  12
  13 #include "includes.h"
  14
  15 #include "common.h"
  16 #include "crypto/random.h"
  17 #include "crypto/sha1.h"
  18 #include "eapol_supp/eapol_supp_sm.h"
  19 #include "eap_peer/eap.h"
  20 #include "eap_peer/eap_proxy.h"
  21 #include "eap_server/eap_methods.h"
  22 #include "rsn_supp/wpa.h"
  23 #include "eloop.h"
  24 #include "config.h"
  25 #include "utils/ext_password.h"
  26 #include "l2_packet/l2_packet.h"
  27 #include "wpa_supplicant_i.h"
  28 #include "driver_i.h"
  29 #include "ctrl_iface.h"
  30 #include "pcsc_funcs.h"
  31 #include "common/version.h"
  32 #include "rsn_supp/preauth.h"
  33 #include "rsn_supp/pmksa_cache.h"
  34 #include "common/wpa_ctrl.h"
  35 #include "common/ieee802_11_defs.h"
  36 #include "common/hw_features_common.h"
  37 #include "p2p/p2p.h"
  38 #include "fst/fst.h"
  39 #include "blacklist.h"
  40 #include "wpas_glue.h"
  41 #include "wps_supplicant.h"
  42 #include "ibss_rsn.h"
  43 #include "sme.h"
  44 #include "gas_query.h"
  45 #include "ap.h"
  46 #include "p2p_supplicant.h"
  47 #include "wifi_display.h"
  48 #include "notify.h"
  49 #include "bgscan.h"
  50 #include "autoscan.h"
  51 #include "bss.h"
  52 #include "scan.h"
  53 #include "offchannel.h"
  54 #include "hs20_supplicant.h"
  55 #include "wnm_sta.h"
  56 #include "wpas_kay.h"
  57 #include "mesh.h"
  58
  59 const char *const wpa_supplicant_version =
  60 "wpa_supplicant v" VERSION_STR "\n"
  61 "Copyright (c) 2003-2016, Jouni Malinen <j@w1.fi> and contributors";
  62
  63 const char *const wpa_supplicant_license =
  64 "This software may be distributed under the terms of the BSD license.\n"
  65 "See README for more details.\n"
  66 #ifdef EAP_TLS_OPENSSL
  67 "\nThis product includes software developed by the OpenSSL Project\n"
  68 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
  69 #endif /* EAP_TLS_OPENSSL */
  70 ;
  71
  72 #ifndef CONFIG_NO_STDOUT_DEBUG
  73 /* Long text divided into parts in order to fit in C89 strings size limits. */
  74 const char *const wpa_supplicant_full_license1 =
  75 "";
  76 const char *const wpa_supplicant_full_license2 =
  77 "This software may be distributed under the terms of the BSD license.\n"
  78 "\n"
  79 "Redistribution and use in source and binary forms, with or without\n"
  80 "modification, are permitted provided that the following conditions are\n"
  81 "met:\n"
  82 "\n";
  83 const char *const wpa_supplicant_full_license3 =
  84 "1. Redistributions of source code must retain the above copyright\n"
  85 "   notice, this list of conditions and the following disclaimer.\n"
  86 "\n"
  87 "2. Redistributions in binary form must reproduce the above copyright\n"
  88 "   notice, this list of conditions and the following disclaimer in the\n"
  89 "   documentation and/or other materials provided with the distribution.\n"
  90 "\n";
  91 const char *const wpa_supplicant_full_license4 =
  92 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
  93 "   names of its contributors may be used to endorse or promote products\n"
  94 "   derived from this software without specific prior written permission.\n"
  95 "\n"
  96 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
  97 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
  98 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
  99 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
 100 const char *const wpa_supplicant_full_license5 =
 101 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
 102 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
 103 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
 104 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
 105 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
 106 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
 107 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
 108 "\n";
 109 #endif /* CONFIG_NO_STDOUT_DEBUG */
 110
 111 /* Configure default/group WEP keys for static WEP */
 112 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
 113 {
 114         int i, set = 0;
 115
 116         for (i = 0; i < NUM_WEP_KEYS; i++) {
 117                 if (ssid->wep_key_len[i] == 0)
 118                         continue;
 119
 120                 set = 1;
 121                 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
 122                                 i, i == ssid->wep_tx_keyidx, NULL, 0,
 123                                 ssid->wep_key[i], ssid->wep_key_len[i]);
 124         }
 125
 126         return set;
 127 }
 128
 129
 130 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
 131                                     struct wpa_ssid *ssid)
 132 {
 133         u8 key[32];
 134         size_t keylen;
 135         enum wpa_alg alg;
 136         u8 seq[6] = { 0 };
 137         int ret;
 138
 139         /* IBSS/WPA-None uses only one key (Group) for both receiving and
 140          * sending unicast and multicast packets. */
 141
 142         if (ssid->mode != WPAS_MODE_IBSS) {
 143                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
 144                         "IBSS/ad-hoc) for WPA-None", ssid->mode);
 145                 return -1;
 146         }
 147
 148         if (!ssid->psk_set) {
 149                 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
 150                         "WPA-None");
 151                 return -1;
 152         }
 153
 154         switch (wpa_s->group_cipher) {
 155         case WPA_CIPHER_CCMP:
 156                 os_memcpy(key, ssid->psk, 16);
 157                 keylen = 16;
 158                 alg = WPA_ALG_CCMP;
 159                 break;
 160         case WPA_CIPHER_GCMP:
 161                 os_memcpy(key, ssid->psk, 16);
 162                 keylen = 16;
 163                 alg = WPA_ALG_GCMP;
 164                 break;
 165         case WPA_CIPHER_TKIP:
 166                 /* WPA-None uses the same Michael MIC key for both TX and RX */
 167                 os_memcpy(key, ssid->psk, 16 + 8);
 168                 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
 169                 keylen = 32;
 170                 alg = WPA_ALG_TKIP;
 171                 break;
 172         default:
 173                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
 174                         "WPA-None", wpa_s->group_cipher);
 175                 return -1;
 176         }
 177
 178         /* TODO: should actually remember the previously used seq#, both for TX
 179          * and RX from each STA.. */
 180
 181         ret = wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
 182         os_memset(key, 0, sizeof(key));
 183         return ret;
 184 }
 185
 186
 187 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 188 {
 189         struct wpa_supplicant *wpa_s = eloop_ctx;
 190         const u8 *bssid = wpa_s->bssid;
 191         if (is_zero_ether_addr(bssid))
 192                 bssid = wpa_s->pending_bssid;
 193         wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
 194                 MAC2STR(bssid));
 195         wpa_blacklist_add(wpa_s, bssid);
 196         wpa_sm_notify_disassoc(wpa_s->wpa);
 197         wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 198         wpa_s->reassociate = 1;
 199
 200         /*
 201          * If we timed out, the AP or the local radio may be busy.
 202          * So, wait a second until scanning again.
 203          */
 204         wpa_supplicant_req_scan(wpa_s, 1, 0);
 205 }
 206
 207
 208 /**
 209  * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
 210  * @wpa_s: Pointer to wpa_supplicant data
 211  * @sec: Number of seconds after which to time out authentication
 212  * @usec: Number of microseconds after which to time out authentication
 213  *
 214  * This function is used to schedule a timeout for the current authentication
 215  * attempt.
 216  */
 217 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 218                                      int sec, int usec)
 219 {
 220         if (wpa_s->conf->ap_scan == 0 &&
 221             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 222                 return;
 223
 224         wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
 225                 "%d usec", sec, usec);
 226         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 227         eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
 228 }
 229
 230
 231 /**
 232  * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
 233  * @wpa_s: Pointer to wpa_supplicant data
 234  *
 235  * This function is used to cancel authentication timeout scheduled with
 236  * wpa_supplicant_req_auth_timeout() and it is called when authentication has
 237  * been completed.
 238  */
 239 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 240 {
 241         wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
 242         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 243         wpa_blacklist_del(wpa_s, wpa_s->bssid);
 244 }
 245
 246
 247 /**
 248  * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
 249  * @wpa_s: Pointer to wpa_supplicant data
 250  *
 251  * This function is used to configure EAPOL state machine based on the selected
 252  * authentication mode.
 253  */
 254 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
 255 {
 256 #ifdef IEEE8021X_EAPOL
 257         struct eapol_config eapol_conf;
 258         struct wpa_ssid *ssid = wpa_s->current_ssid;
 259
 260 #ifdef CONFIG_IBSS_RSN
 261         if (ssid->mode == WPAS_MODE_IBSS &&
 262             wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
 263             wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
 264                 /*
 265                  * RSN IBSS authentication is per-STA and we can disable the
 266                  * per-BSSID EAPOL authentication.
 267                  */
 268                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 269                 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
 270                 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 271                 return;
 272         }
 273 #endif /* CONFIG_IBSS_RSN */
 274
 275         eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 276         eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 277
 278         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
 279             wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
 280                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 281         else
 282                 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
 283
 284         os_memset(&eapol_conf, 0, sizeof(eapol_conf));
 285         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 286                 eapol_conf.accept_802_1x_keys = 1;
 287                 eapol_conf.required_keys = 0;
 288                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
 289                         eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
 290                 }
 291                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
 292                         eapol_conf.required_keys |=
 293                                 EAPOL_REQUIRE_KEY_BROADCAST;
 294                 }
 295
 296                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
 297                         eapol_conf.required_keys = 0;
 298         }
 299         eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
 300         eapol_conf.workaround = ssid->eap_workaround;
 301         eapol_conf.eap_disabled =
 302                 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
 303                 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
 304                 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
 305         eapol_conf.external_sim = wpa_s->conf->external_sim;
 306
 307 #ifdef CONFIG_WPS
 308         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
 309                 eapol_conf.wps |= EAPOL_LOCAL_WPS_IN_USE;
 310                 if (wpa_s->current_bss) {
 311                         struct wpabuf *ie;
 312                         ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
 313                                                          WPS_IE_VENDOR_TYPE);
 314                         if (ie) {
 315                                 if (wps_is_20(ie))
 316                                         eapol_conf.wps |=
 317                                                 EAPOL_PEER_IS_WPS20_AP;
 318                                 wpabuf_free(ie);
 319                         }
 320                 }
 321         }
 322 #endif /* CONFIG_WPS */
 323
 324         eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
 325
 326         ieee802_1x_alloc_kay_sm(wpa_s, ssid);
 327 #endif /* IEEE8021X_EAPOL */
 328 }
 329
 330
 331 /**
 332  * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
 333  * @wpa_s: Pointer to wpa_supplicant data
 334  * @ssid: Configuration data for the network
 335  *
 336  * This function is used to configure WPA state machine and related parameters
 337  * to a mode where WPA is not enabled. This is called as part of the
 338  * authentication configuration when the selected network does not use WPA.
 339  */
 340 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
 341                                        struct wpa_ssid *ssid)
 342 {
 343         int i;
 344
 345         if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
 346                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
 347         else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
 348                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 349         else
 350                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 351         wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
 352         wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
 353         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 354         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 355         wpa_s->group_cipher = WPA_CIPHER_NONE;
 356         wpa_s->mgmt_group_cipher = 0;
 357
 358         for (i = 0; i < NUM_WEP_KEYS; i++) {
 359                 if (ssid->wep_key_len[i] > 5) {
 360                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
 361                         wpa_s->group_cipher = WPA_CIPHER_WEP104;
 362                         break;
 363                 } else if (ssid->wep_key_len[i] > 0) {
 364                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
 365                         wpa_s->group_cipher = WPA_CIPHER_WEP40;
 366                         break;
 367                 }
 368         }
 369
 370         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
 371         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 372         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 373                          wpa_s->pairwise_cipher);
 374         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 375 #ifdef CONFIG_IEEE80211W
 376         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 377                          wpa_s->mgmt_group_cipher);
 378 #endif /* CONFIG_IEEE80211W */
 379
 380         pmksa_cache_clear_current(wpa_s->wpa);
 381 }
 382
 383
 384 void free_hw_features(struct wpa_supplicant *wpa_s)
 385 {
 386         int i;
 387         if (wpa_s->hw.modes == NULL)
 388                 return;
 389
 390         for (i = 0; i < wpa_s->hw.num_modes; i++) {
 391                 os_free(wpa_s->hw.modes[i].channels);
 392                 os_free(wpa_s->hw.modes[i].rates);
 393         }
 394
 395         os_free(wpa_s->hw.modes);
 396         wpa_s->hw.modes = NULL;
 397 }
 398
 399
 400 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 401 {
 402         int i;
 403
 404         bgscan_deinit(wpa_s);
 405         autoscan_deinit(wpa_s);
 406         scard_deinit(wpa_s->scard);
 407         wpa_s->scard = NULL;
 408         wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
 409         eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
 410         l2_packet_deinit(wpa_s->l2);
 411         wpa_s->l2 = NULL;
 412         if (wpa_s->l2_br) {
 413                 l2_packet_deinit(wpa_s->l2_br);
 414                 wpa_s->l2_br = NULL;
 415         }
 416 #ifdef CONFIG_TESTING_OPTIONS
 417         l2_packet_deinit(wpa_s->l2_test);
 418         wpa_s->l2_test = NULL;
 419 #endif /* CONFIG_TESTING_OPTIONS */
 420
 421         if (wpa_s->conf != NULL) {
 422                 struct wpa_ssid *ssid;
 423                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
 424                         wpas_notify_network_removed(wpa_s, ssid);
 425         }
 426
 427         os_free(wpa_s->confname);
 428         wpa_s->confname = NULL;
 429
 430         os_free(wpa_s->confanother);
 431         wpa_s->confanother = NULL;
 432
 433         wpa_sm_set_eapol(wpa_s->wpa, NULL);
 434         eapol_sm_deinit(wpa_s->eapol);
 435         wpa_s->eapol = NULL;
 436
 437         rsn_preauth_deinit(wpa_s->wpa);
 438
 439 #ifdef CONFIG_TDLS
 440         wpa_tdls_deinit(wpa_s->wpa);
 441 #endif /* CONFIG_TDLS */
 442
 443         wmm_ac_clear_saved_tspecs(wpa_s);
 444         pmksa_candidate_free(wpa_s->wpa);
 445         wpa_sm_deinit(wpa_s->wpa);
 446         wpa_s->wpa = NULL;
 447         wpa_blacklist_clear(wpa_s);
 448
 449         wpa_bss_deinit(wpa_s);
 450
 451         wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
 452         wpa_supplicant_cancel_scan(wpa_s);
 453         wpa_supplicant_cancel_auth_timeout(wpa_s);
 454         eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
 455 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
 456         eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
 457                              wpa_s, NULL);
 458 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
 459
 460         eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
 461
 462         wpas_wps_deinit(wpa_s);
 463
 464         wpabuf_free(wpa_s->pending_eapol_rx);
 465         wpa_s->pending_eapol_rx = NULL;
 466
 467 #ifdef CONFIG_IBSS_RSN
 468         ibss_rsn_deinit(wpa_s->ibss_rsn);
 469         wpa_s->ibss_rsn = NULL;
 470 #endif /* CONFIG_IBSS_RSN */
 471
 472         sme_deinit(wpa_s);
 473
 474 #ifdef CONFIG_AP
 475         wpa_supplicant_ap_deinit(wpa_s);
 476 #endif /* CONFIG_AP */
 477
 478         wpas_p2p_deinit(wpa_s);
 479
 480 #ifdef CONFIG_OFFCHANNEL
 481         offchannel_deinit(wpa_s);
 482 #endif /* CONFIG_OFFCHANNEL */
 483
 484         wpa_supplicant_cancel_sched_scan(wpa_s);
 485
 486         os_free(wpa_s->next_scan_freqs);
 487         wpa_s->next_scan_freqs = NULL;
 488
 489         os_free(wpa_s->manual_scan_freqs);
 490         wpa_s->manual_scan_freqs = NULL;
 491
 492         os_free(wpa_s->manual_sched_scan_freqs);
 493         wpa_s->manual_sched_scan_freqs = NULL;
 494
 495         wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
 496
 497         /*
 498          * Need to remove any pending gas-query radio work before the
 499          * gas_query_deinit() call because gas_query::work has not yet been set
 500          * for works that have not been started. gas_query_free() will be unable
 501          * to cancel such pending radio works and once the pending gas-query
 502          * radio work eventually gets removed, the deinit notification call to
 503          * gas_query_start_cb() would result in dereferencing freed memory.
 504          */
 505         if (wpa_s->radio)
 506                 radio_remove_works(wpa_s, "gas-query", 0);
 507         gas_query_deinit(wpa_s->gas);
 508         wpa_s->gas = NULL;
 509
 510         free_hw_features(wpa_s);
 511
 512         ieee802_1x_dealloc_kay_sm(wpa_s);
 513
 514         os_free(wpa_s->bssid_filter);
 515         wpa_s->bssid_filter = NULL;
 516
 517         os_free(wpa_s->disallow_aps_bssid);
 518         wpa_s->disallow_aps_bssid = NULL;
 519         os_free(wpa_s->disallow_aps_ssid);
 520         wpa_s->disallow_aps_ssid = NULL;
 521
 522         wnm_bss_keep_alive_deinit(wpa_s);
 523 #ifdef CONFIG_WNM
 524         wnm_deallocate_memory(wpa_s);
 525 #endif /* CONFIG_WNM */
 526
 527         ext_password_deinit(wpa_s->ext_pw);
 528         wpa_s->ext_pw = NULL;
 529
 530         wpabuf_free(wpa_s->last_gas_resp);
 531         wpa_s->last_gas_resp = NULL;
 532         wpabuf_free(wpa_s->prev_gas_resp);
 533         wpa_s->prev_gas_resp = NULL;
 534
 535         os_free(wpa_s->last_scan_res);
 536         wpa_s->last_scan_res = NULL;
 537
 538 #ifdef CONFIG_HS20
 539         hs20_deinit(wpa_s);
 540 #endif /* CONFIG_HS20 */
 541
 542         for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
 543                 wpabuf_free(wpa_s->vendor_elem[i]);
 544                 wpa_s->vendor_elem[i] = NULL;
 545         }
 546
 547         wmm_ac_notify_disassoc(wpa_s);
 548
 549         wpa_s->sched_scan_plans_num = 0;
 550         os_free(wpa_s->sched_scan_plans);
 551         wpa_s->sched_scan_plans = NULL;
 552
 553 #ifdef CONFIG_MBO
 554         wpa_s->non_pref_chan_num = 0;
 555         os_free(wpa_s->non_pref_chan);
 556         wpa_s->non_pref_chan = NULL;
 557 #endif /* CONFIG_MBO */
 558 }
 559
 560
 561 /**
 562  * wpa_clear_keys - Clear keys configured for the driver
 563  * @wpa_s: Pointer to wpa_supplicant data
 564  * @addr: Previously used BSSID or %NULL if not available
 565  *
 566  * This function clears the encryption keys that has been previously configured
 567  * for the driver.
 568  */
 569 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
 570 {
 571         int i, max;
 572
 573 #ifdef CONFIG_IEEE80211W
 574         max = 6;
 575 #else /* CONFIG_IEEE80211W */
 576         max = 4;
 577 #endif /* CONFIG_IEEE80211W */
 578
 579         /* MLME-DELETEKEYS.request */
 580         for (i = 0; i < max; i++) {
 581                 if (wpa_s->keys_cleared & BIT(i))
 582                         continue;
 583                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
 584                                 NULL, 0);
 585         }
 586         if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
 587             !is_zero_ether_addr(addr)) {
 588                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
 589                                 0);
 590                 /* MLME-SETPROTECTION.request(None) */
 591                 wpa_drv_mlme_setprotection(
 592                         wpa_s, addr,
 593                         MLME_SETPROTECTION_PROTECT_TYPE_NONE,
 594                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 595         }
 596         wpa_s->keys_cleared = (u32) -1;
 597 }
 598
 599
 600 /**
 601  * wpa_supplicant_state_txt - Get the connection state name as a text string
 602  * @state: State (wpa_state; WPA_*)
 603  * Returns: The state name as a printable text string
 604  */
 605 const char * wpa_supplicant_state_txt(enum wpa_states state)
 606 {
 607         switch (state) {
 608         case WPA_DISCONNECTED:
 609                 return "DISCONNECTED";
 610         case WPA_INACTIVE:
 611                 return "INACTIVE";
 612         case WPA_INTERFACE_DISABLED:
 613                 return "INTERFACE_DISABLED";
 614         case WPA_SCANNING:
 615                 return "SCANNING";
 616         case WPA_AUTHENTICATING:
 617                 return "AUTHENTICATING";
 618         case WPA_ASSOCIATING:
 619                 return "ASSOCIATING";
 620         case WPA_ASSOCIATED:
 621                 return "ASSOCIATED";
 622         case WPA_4WAY_HANDSHAKE:
 623                 return "4WAY_HANDSHAKE";
 624         case WPA_GROUP_HANDSHAKE:
 625                 return "GROUP_HANDSHAKE";
 626         case WPA_COMPLETED:
 627                 return "COMPLETED";
 628         default:
 629                 return "UNKNOWN";
 630         }
 631 }
 632
 633
 634 #ifdef CONFIG_BGSCAN
 635
 636 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
 637 {
 638         const char *name;
 639
 640         if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
 641                 name = wpa_s->current_ssid->bgscan;
 642         else
 643                 name = wpa_s->conf->bgscan;
 644         if (name == NULL || name[0] == '\0')
 645                 return;
 646         if (wpas_driver_bss_selection(wpa_s))
 647                 return;
 648         if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
 649                 return;
 650 #ifdef CONFIG_P2P
 651         if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
 652                 return;
 653 #endif /* CONFIG_P2P */
 654
 655         bgscan_deinit(wpa_s);
 656         if (wpa_s->current_ssid) {
 657                 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
 658                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
 659                                 "bgscan");
 660                         /*
 661                          * Live without bgscan; it is only used as a roaming
 662                          * optimization, so the initial connection is not
 663                          * affected.
 664                          */
 665                 } else {
 666                         struct wpa_scan_results *scan_res;
 667                         wpa_s->bgscan_ssid = wpa_s->current_ssid;
 668                         scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
 669                                                                    0);
 670                         if (scan_res) {
 671                                 bgscan_notify_scan(wpa_s, scan_res);
 672                                 wpa_scan_results_free(scan_res);
 673                         }
 674                 }
 675         } else
 676                 wpa_s->bgscan_ssid = NULL;
 677 }
 678
 679
 680 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
 681 {
 682         if (wpa_s->bgscan_ssid != NULL) {
 683                 bgscan_deinit(wpa_s);
 684                 wpa_s->bgscan_ssid = NULL;
 685         }
 686 }
 687
 688 #endif /* CONFIG_BGSCAN */
 689
 690
 691 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
 692 {
 693         if (autoscan_init(wpa_s, 0))
 694                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
 695 }
 696
 697
 698 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
 699 {
 700         autoscan_deinit(wpa_s);
 701 }
 702
 703
 704 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
 705 {
 706         if (wpa_s->wpa_state == WPA_DISCONNECTED ||
 707             wpa_s->wpa_state == WPA_SCANNING) {
 708                 autoscan_deinit(wpa_s);
 709                 wpa_supplicant_start_autoscan(wpa_s);
 710         }
 711 }
 712
 713
 714 /**
 715  * wpa_supplicant_set_state - Set current connection state
 716  * @wpa_s: Pointer to wpa_supplicant data
 717  * @state: The new connection state
 718  *
 719  * This function is called whenever the connection state changes, e.g.,
 720  * association is completed for WPA/WPA2 4-Way Handshake is started.
 721  */
 722 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
 723                               enum wpa_states state)
 724 {
 725         enum wpa_states old_state = wpa_s->wpa_state;
 726
 727         wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
 728                 wpa_supplicant_state_txt(wpa_s->wpa_state),
 729                 wpa_supplicant_state_txt(state));
 730
 731         if (state == WPA_INTERFACE_DISABLED) {
 732                 /* Assure normal scan when interface is restored */
 733                 wpa_s->normal_scans = 0;
 734         }
 735
 736         if (state == WPA_COMPLETED) {
 737                 wpas_connect_work_done(wpa_s);
 738                 /* Reinitialize normal_scan counter */
 739                 wpa_s->normal_scans = 0;
 740         }
 741
 742 #ifdef CONFIG_P2P
 743         /*
 744          * P2PS client has to reply to Probe Request frames received on the
 745          * group operating channel. Enable Probe Request frame reporting for
 746          * P2P connected client in case p2p_cli_probe configuration property is
 747          * set to 1.
 748          */
 749         if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid &&
 750             wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
 751             wpa_s->current_ssid->p2p_group) {
 752                 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) {
 753                         wpa_dbg(wpa_s, MSG_DEBUG,
 754                                 "P2P: Enable CLI Probe Request RX reporting");
 755                         wpa_s->p2p_cli_probe =
 756                                 wpa_drv_probe_req_report(wpa_s, 1) >= 0;
 757                 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) {
 758                         wpa_dbg(wpa_s, MSG_DEBUG,
 759                                 "P2P: Disable CLI Probe Request RX reporting");
 760                         wpa_s->p2p_cli_probe = 0;
 761                         wpa_drv_probe_req_report(wpa_s, 0);
 762                 }
 763         }
 764 #endif /* CONFIG_P2P */
 765
 766         if (state != WPA_SCANNING)
 767                 wpa_supplicant_notify_scanning(wpa_s, 0);
 768
 769         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 770                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 771 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 772                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 773                         MACSTR " completed [id=%d id_str=%s]",
 774                         MAC2STR(wpa_s->bssid),
 775                         ssid ? ssid->id : -1,
 776                         ssid && ssid->id_str ? ssid->id_str : "");
 777 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 778                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
 779                 wpa_blacklist_clear(wpa_s);
 780                 wpa_s->extra_blacklist_count = 0;
 781                 wpa_s->new_connection = 0;
 782                 wpa_drv_set_operstate(wpa_s, 1);
 783 #ifndef IEEE8021X_EAPOL
 784                 wpa_drv_set_supp_port(wpa_s, 1);
 785 #endif /* IEEE8021X_EAPOL */
 786                 wpa_s->after_wps = 0;
 787                 wpa_s->known_wps_freq = 0;
 788                 wpas_p2p_completed(wpa_s);
 789
 790                 sme_sched_obss_scan(wpa_s, 1);
 791         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 792                    state == WPA_ASSOCIATED) {
 793                 wpa_s->new_connection = 1;
 794                 wpa_drv_set_operstate(wpa_s, 0);
 795 #ifndef IEEE8021X_EAPOL
 796                 wpa_drv_set_supp_port(wpa_s, 0);
 797 #endif /* IEEE8021X_EAPOL */
 798                 sme_sched_obss_scan(wpa_s, 0);
 799         }
 800         wpa_s->wpa_state = state;
 801
 802 #ifdef CONFIG_BGSCAN
 803         if (state == WPA_COMPLETED)
 804                 wpa_supplicant_start_bgscan(wpa_s);
 805         else if (state < WPA_ASSOCIATED)
 806                 wpa_supplicant_stop_bgscan(wpa_s);
 807 #endif /* CONFIG_BGSCAN */
 808
 809         if (state == WPA_AUTHENTICATING)
 810                 wpa_supplicant_stop_autoscan(wpa_s);
 811
 812         if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
 813                 wpa_supplicant_start_autoscan(wpa_s);
 814
 815         if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
 816                 wmm_ac_notify_disassoc(wpa_s);
 817
 818         if (wpa_s->wpa_state != old_state) {
 819                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 820
 821                 /*
 822                  * Notify the P2P Device interface about a state change in one
 823                  * of the interfaces.
 824                  */
 825                 wpas_p2p_indicate_state_change(wpa_s);
 826
 827                 if (wpa_s->wpa_state == WPA_COMPLETED ||
 828                     old_state == WPA_COMPLETED)
 829                         wpas_notify_auth_changed(wpa_s);
 830         }
 831 }
 832
 833
 834 void wpa_supplicant_terminate_proc(struct wpa_global *global)
 835 {
 836         int pending = 0;
 837 #ifdef CONFIG_WPS
 838         struct wpa_supplicant *wpa_s = global->ifaces;
 839         while (wpa_s) {
 840                 struct wpa_supplicant *next = wpa_s->next;
 841                 if (wpas_wps_terminate_pending(wpa_s) == 1)
 842                         pending = 1;
 843 #ifdef CONFIG_P2P
 844                 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
 845                     (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
 846                         wpas_p2p_disconnect(wpa_s);
 847 #endif /* CONFIG_P2P */
 848                 wpa_s = next;
 849         }
 850 #endif /* CONFIG_WPS */
 851         if (pending)
 852                 return;
 853         eloop_terminate();
 854 }
 855
 856
 857 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
 858 {
 859         struct wpa_global *global = signal_ctx;
 860         wpa_supplicant_terminate_proc(global);
 861 }
 862
 863
 864 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 865 {
 866         enum wpa_states old_state = wpa_s->wpa_state;
 867
 868         wpa_s->pairwise_cipher = 0;
 869         wpa_s->group_cipher = 0;
 870         wpa_s->mgmt_group_cipher = 0;
 871         wpa_s->key_mgmt = 0;
 872         if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
 873                 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
 874
 875         if (wpa_s->wpa_state != old_state)
 876                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 877 }
 878
 879
 880 /**
 881  * wpa_supplicant_reload_configuration - Reload configuration data
 882  * @wpa_s: Pointer to wpa_supplicant data
 883  * Returns: 0 on success or -1 if configuration parsing failed
 884  *
 885  * This function can be used to request that the configuration data is reloaded
 886  * (e.g., after configuration file change). This function is reloading
 887  * configuration only for one interface, so this may need to be called multiple
 888  * times if %wpa_supplicant is controlling multiple interfaces and all
 889  * interfaces need reconfiguration.
 890  */
 891 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 892 {
 893         struct wpa_config *conf;
 894         int reconf_ctrl;
 895         int old_ap_scan;
 896
 897         if (wpa_s->confname == NULL)
 898                 return -1;
 899         conf = wpa_config_read(wpa_s->confname, NULL);
 900         if (conf == NULL) {
 901                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 902                         "file '%s' - exiting", wpa_s->confname);
 903                 return -1;
 904         }
 905         wpa_config_read(wpa_s->confanother, conf);
 906
 907         conf->changed_parameters = (unsigned int) -1;
 908
 909         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 910                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 911                     os_strcmp(conf->ctrl_interface,
 912                               wpa_s->conf->ctrl_interface) != 0);
 913
 914         if (reconf_ctrl && wpa_s->ctrl_iface) {
 915                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 916                 wpa_s->ctrl_iface = NULL;
 917         }
 918
 919         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 920         if (wpa_s->current_ssid) {
 921                 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
 922                         wpa_s->own_disconnect_req = 1;
 923                 wpa_supplicant_deauthenticate(wpa_s,
 924                                               WLAN_REASON_DEAUTH_LEAVING);
 925         }
 926
 927         /*
 928          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 929          * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
 930          */
 931         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 932                 /*
 933                  * Clear forced success to clear EAP state for next
 934                  * authentication.
 935                  */
 936                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 937         }
 938         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 939         wpa_sm_set_config(wpa_s->wpa, NULL);
 940         wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
 941         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 942         rsn_preauth_deinit(wpa_s->wpa);
 943
 944         old_ap_scan = wpa_s->conf->ap_scan;
 945         wpa_config_free(wpa_s->conf);
 946         wpa_s->conf = conf;
 947         if (old_ap_scan != wpa_s->conf->ap_scan)
 948                 wpas_notify_ap_scan_changed(wpa_s);
 949
 950         if (reconf_ctrl)
 951                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 952
 953         wpa_supplicant_update_config(wpa_s);
 954
 955         wpa_supplicant_clear_status(wpa_s);
 956         if (wpa_supplicant_enabled_networks(wpa_s)) {
 957                 wpa_s->reassociate = 1;
 958                 wpa_supplicant_req_scan(wpa_s, 0, 0);
 959         }
 960         wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 961         return 0;
 962 }
 963
 964
 965 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
 966 {
 967         struct wpa_global *global = signal_ctx;
 968         struct wpa_supplicant *wpa_s;
 969         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 970                 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
 971                         sig);
 972                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 973                         wpa_supplicant_terminate_proc(global);
 974                 }
 975         }
 976
 977         if (wpa_debug_reopen_file() < 0) {
 978                 /* Ignore errors since we cannot really do much to fix this */
 979                 wpa_printf(MSG_DEBUG, "Could not reopen debug log file");
 980         }
 981 }
 982
 983
 984 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 985                                          struct wpa_ssid *ssid,
 986                                          struct wpa_ie_data *ie)
 987 {
 988         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 989         if (ret) {
 990                 if (ret == -2) {
 991                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 992                                 "from association info");
 993                 }
 994                 return -1;
 995         }
 996
 997         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
 998                 "cipher suites");
 999         if (!(ie->group_cipher & ssid->group_cipher)) {
1000                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
1001                         "cipher 0x%x (mask 0x%x) - reject",
1002                         ie->group_cipher, ssid->group_cipher);
1003                 return -1;
1004         }
1005         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
1006                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
1007                         "cipher 0x%x (mask 0x%x) - reject",
1008                         ie->pairwise_cipher, ssid->pairwise_cipher);
1009                 return -1;
1010         }
1011         if (!(ie->key_mgmt & ssid->key_mgmt)) {
1012                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
1013                         "management 0x%x (mask 0x%x) - reject",
1014                         ie->key_mgmt, ssid->key_mgmt);
1015                 return -1;
1016         }
1017
1018 #ifdef CONFIG_IEEE80211W
1019         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
1020             wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
1021                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
1022                         "that does not support management frame protection - "
1023                         "reject");
1024                 return -1;
1025         }
1026 #endif /* CONFIG_IEEE80211W */
1027
1028         return 0;
1029 }
1030
1031
1032 /**
1033  * wpa_supplicant_set_suites - Set authentication and encryption parameters
1034  * @wpa_s: Pointer to wpa_supplicant data
1035  * @bss: Scan results for the selected BSS, or %NULL if not available
1036  * @ssid: Configuration data for the selected network
1037  * @wpa_ie: Buffer for the WPA/RSN IE
1038  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
1039  * used buffer length in case the functions returns success.
1040  * Returns: 0 on success or -1 on failure
1041  *
1042  * This function is used to configure authentication and encryption parameters
1043  * based on the network configuration and scan result for the selected BSS (if
1044  * available).
1045  */
1046 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
1047                               struct wpa_bss *bss, struct wpa_ssid *ssid,
1048                               u8 *wpa_ie, size_t *wpa_ie_len)
1049 {
1050         struct wpa_ie_data ie;
1051         int sel, proto;
1052         const u8 *bss_wpa, *bss_rsn, *bss_osen;
1053
1054         if (bss) {
1055                 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
1056                 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1057                 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
1058         } else
1059                 bss_wpa = bss_rsn = bss_osen = NULL;
1060
1061         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
1062             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
1063             (ie.group_cipher & ssid->group_cipher) &&
1064             (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1065             (ie.key_mgmt & ssid->key_mgmt)) {
1066                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1067                 proto = WPA_PROTO_RSN;
1068         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
1069                    wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie) == 0 &&
1070                    (ie.group_cipher & ssid->group_cipher) &&
1071                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1072                    (ie.key_mgmt & ssid->key_mgmt)) {
1073                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1074                 proto = WPA_PROTO_WPA;
1075 #ifdef CONFIG_HS20
1076         } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN)) {
1077                 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1078                 /* TODO: parse OSEN element */
1079                 os_memset(&ie, 0, sizeof(ie));
1080                 ie.group_cipher = WPA_CIPHER_CCMP;
1081                 ie.pairwise_cipher = WPA_CIPHER_CCMP;
1082                 ie.key_mgmt = WPA_KEY_MGMT_OSEN;
1083                 proto = WPA_PROTO_OSEN;
1084 #endif /* CONFIG_HS20 */
1085         } else if (bss) {
1086                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1087                 wpa_dbg(wpa_s, MSG_DEBUG,
1088                         "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1089                         ssid->proto, ssid->pairwise_cipher, ssid->group_cipher,
1090                         ssid->key_mgmt);
1091                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1092                         MAC2STR(bss->bssid),
1093                         wpa_ssid_txt(bss->ssid, bss->ssid_len),
1094                         bss_wpa ? " WPA" : "",
1095                         bss_rsn ? " RSN" : "",
1096                         bss_osen ? " OSEN" : "");
1097                 if (bss_rsn) {
1098                         wpa_hexdump(MSG_DEBUG, "RSN", bss_rsn, 2 + bss_rsn[1]);
1099                         if (wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie)) {
1100                                 wpa_dbg(wpa_s, MSG_DEBUG,
1101                                         "Could not parse RSN element");
1102                         } else {
1103                                 wpa_dbg(wpa_s, MSG_DEBUG,
1104                                         "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1105                                         ie.pairwise_cipher, ie.group_cipher,
1106                                         ie.key_mgmt);
1107                         }
1108                 }
1109                 if (bss_wpa) {
1110                         wpa_hexdump(MSG_DEBUG, "WPA", bss_wpa, 2 + bss_wpa[1]);
1111                         if (wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie)) {
1112                                 wpa_dbg(wpa_s, MSG_DEBUG,
1113                                         "Could not parse WPA element");
1114                         } else {
1115                                 wpa_dbg(wpa_s, MSG_DEBUG,
1116                                         "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1117                                         ie.pairwise_cipher, ie.group_cipher,
1118                                         ie.key_mgmt);
1119                         }
1120                 }
1121                 return -1;
1122         } else {
1123                 if (ssid->proto & WPA_PROTO_OSEN)
1124                         proto = WPA_PROTO_OSEN;
1125                 else if (ssid->proto & WPA_PROTO_RSN)
1126                         proto = WPA_PROTO_RSN;
1127                 else
1128                         proto = WPA_PROTO_WPA;
1129                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1130                         os_memset(&ie, 0, sizeof(ie));
1131                         ie.group_cipher = ssid->group_cipher;
1132                         ie.pairwise_cipher = ssid->pairwise_cipher;
1133                         ie.key_mgmt = ssid->key_mgmt;
1134 #ifdef CONFIG_IEEE80211W
1135                         ie.mgmt_group_cipher =
1136                                 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
1137                                 WPA_CIPHER_AES_128_CMAC : 0;
1138 #endif /* CONFIG_IEEE80211W */
1139                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1140                                 "based on configuration");
1141                 } else
1142                         proto = ie.proto;
1143         }
1144
1145         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1146                 "pairwise %d key_mgmt %d proto %d",
1147                 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
1148 #ifdef CONFIG_IEEE80211W
1149         if (ssid->ieee80211w) {
1150                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1151                         ie.mgmt_group_cipher);
1152         }
1153 #endif /* CONFIG_IEEE80211W */
1154
1155         wpa_s->wpa_proto = proto;
1156         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1157         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1158                          !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)));
1159
1160         if (bss || !wpa_s->ap_ies_from_associnfo) {
1161                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1162                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
1163                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1164                                          bss_rsn ? 2 + bss_rsn[1] : 0))
1165                         return -1;
1166         }
1167
1168 #ifdef CONFIG_NO_WPA
1169         wpa_s->group_cipher = WPA_CIPHER_NONE;
1170         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1171 #else /* CONFIG_NO_WPA */
1172         sel = ie.group_cipher & ssid->group_cipher;
1173         wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1174         if (wpa_s->group_cipher < 0) {
1175                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1176                         "cipher");
1177                 return -1;
1178         }
1179         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1180                 wpa_cipher_txt(wpa_s->group_cipher));
1181
1182         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
1183         wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1184         if (wpa_s->pairwise_cipher < 0) {
1185                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1186                         "cipher");
1187                 return -1;
1188         }
1189         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1190                 wpa_cipher_txt(wpa_s->pairwise_cipher));
1191 #endif /* CONFIG_NO_WPA */
1192
1193         sel = ie.key_mgmt & ssid->key_mgmt;
1194 #ifdef CONFIG_SAE
1195         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1196                 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
1197 #endif /* CONFIG_SAE */
1198         if (0) {
1199 #ifdef CONFIG_SUITEB192
1200         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
1201                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1202                 wpa_dbg(wpa_s, MSG_DEBUG,
1203                         "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)");
1204 #endif /* CONFIG_SUITEB192 */
1205 #ifdef CONFIG_SUITEB
1206         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1207                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1208                 wpa_dbg(wpa_s, MSG_DEBUG,
1209                         "WPA: using KEY_MGMT 802.1X with Suite B");
1210 #endif /* CONFIG_SUITEB */
1211 #ifdef CONFIG_IEEE80211R
1212         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1213                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1214                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1215         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1216                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1217                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1218 #endif /* CONFIG_IEEE80211R */
1219 #ifdef CONFIG_SAE
1220         } else if (sel & WPA_KEY_MGMT_SAE) {
1221                 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1222                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1223         } else if (sel & WPA_KEY_MGMT_FT_SAE) {
1224                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1225                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1226 #endif /* CONFIG_SAE */
1227 #ifdef CONFIG_IEEE80211W
1228         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1229                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1230                 wpa_dbg(wpa_s, MSG_DEBUG,
1231                         "WPA: using KEY_MGMT 802.1X with SHA256");
1232         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1233                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1234                 wpa_dbg(wpa_s, MSG_DEBUG,
1235                         "WPA: using KEY_MGMT PSK with SHA256");
1236 #endif /* CONFIG_IEEE80211W */
1237         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1238                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1239                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1240         } else if (sel & WPA_KEY_MGMT_PSK) {
1241                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1242                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1243         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1244                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1245                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1246 #ifdef CONFIG_HS20
1247         } else if (sel & WPA_KEY_MGMT_OSEN) {
1248                 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1249                 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1250 #endif /* CONFIG_HS20 */
1251         } else {
1252                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1253                         "authenticated key management type");
1254                 return -1;
1255         }
1256
1257         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1258         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1259                          wpa_s->pairwise_cipher);
1260         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1261
1262 #ifdef CONFIG_IEEE80211W
1263         sel = ie.mgmt_group_cipher;
1264         if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1265             !(ie.capabilities & WPA_CAPABILITY_MFPC))
1266                 sel = 0;
1267         if (sel & WPA_CIPHER_AES_128_CMAC) {
1268                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1269                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1270                         "AES-128-CMAC");
1271         } else if (sel & WPA_CIPHER_BIP_GMAC_128) {
1272                 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1273                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1274                         "BIP-GMAC-128");
1275         } else if (sel & WPA_CIPHER_BIP_GMAC_256) {
1276                 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1277                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1278                         "BIP-GMAC-256");
1279         } else if (sel & WPA_CIPHER_BIP_CMAC_256) {
1280                 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1281                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1282                         "BIP-CMAC-256");
1283         } else {
1284                 wpa_s->mgmt_group_cipher = 0;
1285                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1286         }
1287         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1288                          wpa_s->mgmt_group_cipher);
1289         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1290                          wpas_get_ssid_pmf(wpa_s, ssid));
1291 #endif /* CONFIG_IEEE80211W */
1292
1293         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1294                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1295                 return -1;
1296         }
1297
1298         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
1299                 int psk_set = 0;
1300
1301                 if (ssid->psk_set) {
1302                         wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL,
1303                                        NULL);
1304                         psk_set = 1;
1305                 }
1306 #ifndef CONFIG_NO_PBKDF2
1307                 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1308                     ssid->passphrase) {
1309                         u8 psk[PMK_LEN];
1310                         pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1311                                     4096, psk, PMK_LEN);
1312                         wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1313                                         psk, PMK_LEN);
1314                         wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL, NULL);
1315                         psk_set = 1;
1316                         os_memset(psk, 0, sizeof(psk));
1317                 }
1318 #endif /* CONFIG_NO_PBKDF2 */
1319 #ifdef CONFIG_EXT_PASSWORD
1320                 if (ssid->ext_psk) {
1321                         struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1322                                                              ssid->ext_psk);
1323                         char pw_str[64 + 1];
1324                         u8 psk[PMK_LEN];
1325
1326                         if (pw == NULL) {
1327                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1328                                         "found from external storage");
1329                                 return -1;
1330                         }
1331
1332                         if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1333                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1334                                         "PSK length %d in external storage",
1335                                         (int) wpabuf_len(pw));
1336                                 ext_password_free(pw);
1337                                 return -1;
1338                         }
1339
1340                         os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1341                         pw_str[wpabuf_len(pw)] = '\0';
1342
1343 #ifndef CONFIG_NO_PBKDF2
1344                         if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1345                         {
1346                                 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1347                                             4096, psk, PMK_LEN);
1348                                 os_memset(pw_str, 0, sizeof(pw_str));
1349                                 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1350                                                 "external passphrase)",
1351                                                 psk, PMK_LEN);
1352                                 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1353                                                NULL);
1354                                 psk_set = 1;
1355                                 os_memset(psk, 0, sizeof(psk));
1356                         } else
1357 #endif /* CONFIG_NO_PBKDF2 */
1358                         if (wpabuf_len(pw) == 2 * PMK_LEN) {
1359                                 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1360                                         wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1361                                                 "Invalid PSK hex string");
1362                                         os_memset(pw_str, 0, sizeof(pw_str));
1363                                         ext_password_free(pw);
1364                                         return -1;
1365                                 }
1366                                 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1367                                                NULL);
1368                                 psk_set = 1;
1369                                 os_memset(psk, 0, sizeof(psk));
1370                         } else {
1371                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1372                                         "PSK available");
1373                                 os_memset(pw_str, 0, sizeof(pw_str));
1374                                 ext_password_free(pw);
1375                                 return -1;
1376                         }
1377
1378                         os_memset(pw_str, 0, sizeof(pw_str));
1379                         ext_password_free(pw);
1380                 }
1381 #endif /* CONFIG_EXT_PASSWORD */
1382
1383                 if (!psk_set) {
1384                         wpa_msg(wpa_s, MSG_INFO,
1385                                 "No PSK available for association");
1386                         return -1;
1387                 }
1388         } else
1389                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1390
1391         return 0;
1392 }
1393
1394
1395 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1396 {
1397         *pos = 0x00;
1398
1399         switch (idx) {
1400         case 0: /* Bits 0-7 */
1401                 break;
1402         case 1: /* Bits 8-15 */
1403                 break;
1404         case 2: /* Bits 16-23 */
1405 #ifdef CONFIG_WNM
1406                 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */
1407                 *pos |= 0x08; /* Bit 19 - BSS Transition */
1408 #endif /* CONFIG_WNM */
1409                 break;
1410         case 3: /* Bits 24-31 */
1411 #ifdef CONFIG_WNM
1412                 *pos |= 0x02; /* Bit 25 - SSID List */
1413 #endif /* CONFIG_WNM */
1414 #ifdef CONFIG_INTERWORKING
1415                 if (wpa_s->conf->interworking)
1416                         *pos |= 0x80; /* Bit 31 - Interworking */
1417 #endif /* CONFIG_INTERWORKING */
1418                 break;
1419         case 4: /* Bits 32-39 */
1420 #ifdef CONFIG_INTERWORKING
1421                 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1422                         *pos |= 0x01; /* Bit 32 - QoS Map */
1423 #endif /* CONFIG_INTERWORKING */
1424                 break;
1425         case 5: /* Bits 40-47 */
1426 #ifdef CONFIG_HS20
1427                 if (wpa_s->conf->hs20)
1428                         *pos |= 0x40; /* Bit 46 - WNM-Notification */
1429 #endif /* CONFIG_HS20 */
1430 #ifdef CONFIG_MBO
1431                 *pos |= 0x40; /* Bit 46 - WNM-Notification */
1432 #endif /* CONFIG_MBO */
1433                 break;
1434         case 6: /* Bits 48-55 */
1435                 break;
1436         }
1437 }
1438
1439
1440 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1441 {
1442         u8 *pos = buf;
1443         u8 len = 6, i;
1444
1445         if (len < wpa_s->extended_capa_len)
1446                 len = wpa_s->extended_capa_len;
1447         if (buflen < (size_t) len + 2) {
1448                 wpa_printf(MSG_INFO,
1449                            "Not enough room for building extended capabilities element");
1450                 return -1;
1451         }
1452
1453         *pos++ = WLAN_EID_EXT_CAPAB;
1454         *pos++ = len;
1455         for (i = 0; i < len; i++, pos++) {
1456                 wpas_ext_capab_byte(wpa_s, pos, i);
1457
1458                 if (i < wpa_s->extended_capa_len) {
1459                         *pos &= ~wpa_s->extended_capa_mask[i];
1460                         *pos |= wpa_s->extended_capa[i];
1461                 }
1462         }
1463
1464         while (len > 0 && buf[1 + len] == 0) {
1465                 len--;
1466                 buf[1] = len;
1467         }
1468         if (len == 0)
1469                 return 0;
1470
1471         return 2 + len;
1472 }
1473
1474
1475 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1476                           struct wpa_bss *test_bss)
1477 {
1478         struct wpa_bss *bss;
1479
1480         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1481                 if (bss == test_bss)
1482                         return 1;
1483         }
1484
1485         return 0;
1486 }
1487
1488
1489 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1490                            struct wpa_ssid *test_ssid)
1491 {
1492         struct wpa_ssid *ssid;
1493
1494         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1495                 if (ssid == test_ssid)
1496                         return 1;
1497         }
1498
1499         return 0;
1500 }
1501
1502
1503 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1504                         struct wpa_ssid *test_ssid)
1505 {
1506         if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1507                 return 0;
1508
1509         return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1510 }
1511
1512
1513 void wpas_connect_work_free(struct wpa_connect_work *cwork)
1514 {
1515         if (cwork == NULL)
1516                 return;
1517         os_free(cwork);
1518 }
1519
1520
1521 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1522 {
1523         struct wpa_connect_work *cwork;
1524         struct wpa_radio_work *work = wpa_s->connect_work;
1525
1526         if (!work)
1527                 return;
1528
1529         wpa_s->connect_work = NULL;
1530         cwork = work->ctx;
1531         work->ctx = NULL;
1532         wpas_connect_work_free(cwork);
1533         radio_work_done(work);
1534 }
1535
1536
1537 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1538 {
1539         struct os_reltime now;
1540         u8 addr[ETH_ALEN];
1541
1542         os_get_reltime(&now);
1543         if (wpa_s->last_mac_addr_style == style &&
1544             wpa_s->last_mac_addr_change.sec != 0 &&
1545             !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1546                                 wpa_s->conf->rand_addr_lifetime)) {
1547                 wpa_msg(wpa_s, MSG_DEBUG,
1548                         "Previously selected random MAC address has not yet expired");
1549                 return 0;
1550         }
1551
1552         switch (style) {
1553         case 1:
1554                 if (random_mac_addr(addr) < 0)
1555                         return -1;
1556                 break;
1557         case 2:
1558                 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1559                 if (random_mac_addr_keep_oui(addr) < 0)
1560                         return -1;
1561                 break;
1562         default:
1563                 return -1;
1564         }
1565
1566         if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1567                 wpa_msg(wpa_s, MSG_INFO,
1568                         "Failed to set random MAC address");
1569                 return -1;
1570         }
1571
1572         os_get_reltime(&wpa_s->last_mac_addr_change);
1573         wpa_s->mac_addr_changed = 1;
1574         wpa_s->last_mac_addr_style = style;
1575
1576         if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1577                 wpa_msg(wpa_s, MSG_INFO,
1578                         "Could not update MAC address information");
1579                 return -1;
1580         }
1581
1582         wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1583                 MAC2STR(addr));
1584
1585         return 0;
1586 }
1587
1588
1589 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1590 {
1591         if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1592             !wpa_s->conf->preassoc_mac_addr)
1593                 return 0;
1594
1595         return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1596 }
1597
1598
1599 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit);
1600
1601 /**
1602  * wpa_supplicant_associate - Request association
1603  * @wpa_s: Pointer to wpa_supplicant data
1604  * @bss: Scan results for the selected BSS, or %NULL if not available
1605  * @ssid: Configuration data for the selected network
1606  *
1607  * This function is used to request %wpa_supplicant to associate with a BSS.
1608  */
1609 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1610                               struct wpa_bss *bss, struct wpa_ssid *ssid)
1611 {
1612         struct wpa_connect_work *cwork;
1613         int rand_style;
1614
1615         wpa_s->own_disconnect_req = 0;
1616
1617         /*
1618          * If we are starting a new connection, any previously pending EAPOL
1619          * RX cannot be valid anymore.
1620          */
1621         wpabuf_free(wpa_s->pending_eapol_rx);
1622         wpa_s->pending_eapol_rx = NULL;
1623
1624         if (ssid->mac_addr == -1)
1625                 rand_style = wpa_s->conf->mac_addr;
1626         else
1627                 rand_style = ssid->mac_addr;
1628
1629         wmm_ac_clear_saved_tspecs(wpa_s);
1630         wpa_s->reassoc_same_bss = 0;
1631
1632         if (wpa_s->last_ssid == ssid) {
1633                 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1634                 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1635                         wmm_ac_save_tspecs(wpa_s);
1636                         wpa_s->reassoc_same_bss = 1;
1637                 }
1638         } else if (rand_style > 0) {
1639                 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1640                         return;
1641                 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1642         } else if (wpa_s->mac_addr_changed) {
1643                 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1644                         wpa_msg(wpa_s, MSG_INFO,
1645                                 "Could not restore permanent MAC address");
1646                         return;
1647                 }
1648                 wpa_s->mac_addr_changed = 0;
1649                 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1650                         wpa_msg(wpa_s, MSG_INFO,
1651                                 "Could not update MAC address information");
1652                         return;
1653                 }
1654                 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1655         }
1656         wpa_s->last_ssid = ssid;
1657
1658 #ifdef CONFIG_IBSS_RSN
1659         ibss_rsn_deinit(wpa_s->ibss_rsn);
1660         wpa_s->ibss_rsn = NULL;
1661 #endif /* CONFIG_IBSS_RSN */
1662
1663         if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1664             ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1665 #ifdef CONFIG_AP
1666                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1667                         wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1668                                 "mode");
1669                         return;
1670                 }
1671                 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1672                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1673                         if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1674                                 wpas_p2p_ap_setup_failed(wpa_s);
1675                         return;
1676                 }
1677                 wpa_s->current_bss = bss;
1678 #else /* CONFIG_AP */
1679                 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1680                         "the build");
1681 #endif /* CONFIG_AP */
1682                 return;
1683         }
1684
1685         if (ssid->mode == WPAS_MODE_MESH) {
1686 #ifdef CONFIG_MESH
1687                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
1688                         wpa_msg(wpa_s, MSG_INFO,
1689                                 "Driver does not support mesh mode");
1690                         return;
1691                 }
1692                 if (bss)
1693                         ssid->frequency = bss->freq;
1694                 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
1695                         wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
1696                         return;
1697                 }
1698                 wpa_s->current_bss = bss;
1699                 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_STARTED "ssid=\"%s\" id=%d",
1700                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
1701                         ssid->id);
1702 #else /* CONFIG_MESH */
1703                 wpa_msg(wpa_s, MSG_ERROR,
1704                         "mesh mode support not included in the build");
1705 #endif /* CONFIG_MESH */
1706                 return;
1707         }
1708
1709 #ifdef CONFIG_TDLS
1710         if (bss)
1711                 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1712                                 bss->ie_len);
1713 #endif /* CONFIG_TDLS */
1714
1715         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1716             ssid->mode == IEEE80211_MODE_INFRA) {
1717                 sme_authenticate(wpa_s, bss, ssid);
1718                 return;
1719         }
1720
1721         if (wpa_s->connect_work) {
1722                 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1723                 return;
1724         }
1725
1726         if (radio_work_pending(wpa_s, "connect")) {
1727                 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1728                 return;
1729         }
1730
1731         wpas_abort_ongoing_scan(wpa_s);
1732
1733         cwork = os_zalloc(sizeof(*cwork));
1734         if (cwork == NULL)
1735                 return;
1736
1737         cwork->bss = bss;
1738         cwork->ssid = ssid;
1739
1740         if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1741                            wpas_start_assoc_cb, cwork) < 0) {
1742                 os_free(cwork);
1743         }
1744 }
1745
1746
1747 static int bss_is_ibss(struct wpa_bss *bss)
1748 {
1749         return (bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) ==
1750                 IEEE80211_CAP_IBSS;
1751 }
1752
1753
1754 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
1755                             const struct wpa_ssid *ssid)
1756 {
1757         enum hostapd_hw_mode hw_mode;
1758         struct hostapd_hw_modes *mode = NULL;
1759         u8 channel;
1760         int i;
1761
1762 #ifdef CONFIG_HT_OVERRIDES
1763         if (ssid->disable_ht)
1764                 return 0;
1765 #endif /* CONFIG_HT_OVERRIDES */
1766
1767         hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel);
1768         if (hw_mode == NUM_HOSTAPD_MODES)
1769                 return 0;
1770         for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1771                 if (wpa_s->hw.modes[i].mode == hw_mode) {
1772                         mode = &wpa_s->hw.modes[i];
1773                         break;
1774                 }
1775         }
1776
1777         if (!mode)
1778                 return 0;
1779
1780         return mode->vht_capab != 0;
1781 }
1782
1783
1784 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
1785                           const struct wpa_ssid *ssid,
1786                           struct hostapd_freq_params *freq)
1787 {
1788         enum hostapd_hw_mode hw_mode;
1789         struct hostapd_hw_modes *mode = NULL;
1790         int ht40plus[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1791                            184, 192 };
1792         int vht80[] = { 36, 52, 100, 116, 132, 149 };
1793         struct hostapd_channel_data *pri_chan = NULL, *sec_chan = NULL;
1794         u8 channel;
1795         int i, chan_idx, ht40 = -1, res, obss_scan = 1;
1796         unsigned int j, k;
1797         struct hostapd_freq_params vht_freq;
1798         int chwidth, seg0, seg1;
1799         u32 vht_caps = 0;
1800
1801         freq->freq = ssid->frequency;
1802
1803         for (j = 0; j < wpa_s->last_scan_res_used; j++) {
1804                 struct wpa_bss *bss = wpa_s->last_scan_res[j];
1805
1806                 if (ssid->mode != WPAS_MODE_IBSS)
1807                         break;
1808
1809                 /* Don't adjust control freq in case of fixed_freq */
1810                 if (ssid->fixed_freq)
1811                         break;
1812
1813                 if (!bss_is_ibss(bss))
1814                         continue;
1815
1816                 if (ssid->ssid_len == bss->ssid_len &&
1817                     os_memcmp(ssid->ssid, bss->ssid, bss->ssid_len) == 0) {
1818                         wpa_printf(MSG_DEBUG,
1819                                    "IBSS already found in scan results, adjust control freq: %d",
1820                                    bss->freq);
1821                         freq->freq = bss->freq;
1822                         obss_scan = 0;
1823                         break;
1824                 }
1825         }
1826
1827         /* For IBSS check HT_IBSS flag */
1828         if (ssid->mode == WPAS_MODE_IBSS &&
1829             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
1830                 return;
1831
1832         if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
1833             wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
1834             wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
1835                 wpa_printf(MSG_DEBUG,
1836                            "IBSS: WEP/TKIP detected, do not try to enable HT");
1837                 return;
1838         }
1839
1840         hw_mode = ieee80211_freq_to_chan(freq->freq, &channel);
1841         for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1842                 if (wpa_s->hw.modes[i].mode == hw_mode) {
1843                         mode = &wpa_s->hw.modes[i];
1844                         break;
1845                 }
1846         }
1847
1848         if (!mode)
1849                 return;
1850
1851         freq->ht_enabled = ht_supported(mode);
1852         if (!freq->ht_enabled)
1853                 return;
1854
1855         /* Setup higher BW only for 5 GHz */
1856         if (mode->mode != HOSTAPD_MODE_IEEE80211A)
1857                 return;
1858
1859         for (chan_idx = 0; chan_idx < mode->num_channels; chan_idx++) {
1860                 pri_chan = &mode->channels[chan_idx];
1861                 if (pri_chan->chan == channel)
1862                         break;
1863                 pri_chan = NULL;
1864         }
1865         if (!pri_chan)
1866                 return;
1867
1868         /* Check primary channel flags */
1869         if (pri_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1870                 return;
1871
1872         /* Check/setup HT40+/HT40- */
1873         for (j = 0; j < ARRAY_SIZE(ht40plus); j++) {
1874                 if (ht40plus[j] == channel) {
1875                         ht40 = 1;
1876                         break;
1877                 }
1878         }
1879
1880         /* Find secondary channel */
1881         for (i = 0; i < mode->num_channels; i++) {
1882                 sec_chan = &mode->channels[i];
1883                 if (sec_chan->chan == channel + ht40 * 4)
1884                         break;
1885                 sec_chan = NULL;
1886         }
1887         if (!sec_chan)
1888                 return;
1889
1890         /* Check secondary channel flags */
1891         if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1892                 return;
1893
1894         freq->channel = pri_chan->chan;
1895
1896         switch (ht40) {
1897         case -1:
1898                 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS))
1899                         return;
1900                 freq->sec_channel_offset = -1;
1901                 break;
1902         case 1:
1903                 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS))
1904                         return;
1905                 freq->sec_channel_offset = 1;
1906                 break;
1907         default:
1908                 break;
1909         }
1910
1911         if (freq->sec_channel_offset && obss_scan) {
1912                 struct wpa_scan_results *scan_res;
1913
1914                 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
1915                 if (scan_res == NULL) {
1916                         /* Back to HT20 */
1917                         freq->sec_channel_offset = 0;
1918                         return;
1919                 }
1920
1921                 res = check_40mhz_5g(mode, scan_res, pri_chan->chan,
1922                                      sec_chan->chan);
1923                 switch (res) {
1924                 case 0:
1925                         /* Back to HT20 */
1926                         freq->sec_channel_offset = 0;
1927                         break;
1928                 case 1:
1929                         /* Configuration allowed */
1930                         break;
1931                 case 2:
1932                         /* Switch pri/sec channels */
1933                         freq->freq = hw_get_freq(mode, sec_chan->chan);
1934                         freq->sec_channel_offset = -freq->sec_channel_offset;
1935                         freq->channel = sec_chan->chan;
1936                         break;
1937                 default:
1938                         freq->sec_channel_offset = 0;
1939                         break;
1940                 }
1941
1942                 wpa_scan_results_free(scan_res);
1943         }
1944
1945         wpa_printf(MSG_DEBUG,
1946                    "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
1947                    freq->channel, freq->sec_channel_offset);
1948
1949         if (!drv_supports_vht(wpa_s, ssid))
1950                 return;
1951
1952         /* For IBSS check VHT_IBSS flag */
1953         if (ssid->mode == WPAS_MODE_IBSS &&
1954             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
1955                 return;
1956
1957         vht_freq = *freq;
1958
1959         vht_freq.vht_enabled = vht_supported(mode);
1960         if (!vht_freq.vht_enabled)
1961                 return;
1962
1963         /* setup center_freq1, bandwidth */
1964         for (j = 0; j < ARRAY_SIZE(vht80); j++) {
1965                 if (freq->channel >= vht80[j] &&
1966                     freq->channel < vht80[j] + 16)
1967                         break;
1968         }
1969
1970         if (j == ARRAY_SIZE(vht80))
1971                 return;
1972
1973         for (i = vht80[j]; i < vht80[j] + 16; i += 4) {
1974                 struct hostapd_channel_data *chan;
1975
1976                 chan = hw_get_channel_chan(mode, i, NULL);
1977                 if (!chan)
1978                         return;
1979
1980                 /* Back to HT configuration if channel not usable */
1981                 if (chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1982                         return;
1983         }
1984
1985         chwidth = VHT_CHANWIDTH_80MHZ;
1986         seg0 = vht80[j] + 6;
1987         seg1 = 0;
1988
1989         if (ssid->max_oper_chwidth == VHT_CHANWIDTH_80P80MHZ) {
1990                 /* setup center_freq2, bandwidth */
1991                 for (k = 0; k < ARRAY_SIZE(vht80); k++) {
1992                         /* Only accept 80 MHz segments separated by a gap */
1993                         if (j == k || abs(vht80[j] - vht80[k]) == 16)
1994                                 continue;
1995                         for (i = vht80[k]; i < vht80[k] + 16; i += 4) {
1996                                 struct hostapd_channel_data *chan;
1997
1998                                 chan = hw_get_channel_chan(mode, i, NULL);
1999                                 if (!chan)
2000                                         continue;
2001
2002                                 if (chan->flag & (HOSTAPD_CHAN_DISABLED |
2003                                                   HOSTAPD_CHAN_NO_IR |
2004                                                   HOSTAPD_CHAN_RADAR))
2005                                         continue;
2006
2007                                 /* Found a suitable second segment for 80+80 */
2008                                 chwidth = VHT_CHANWIDTH_80P80MHZ;
2009                                 vht_caps |=
2010                                         VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
2011                                 seg1 = vht80[k] + 6;
2012                         }
2013
2014                         if (chwidth == VHT_CHANWIDTH_80P80MHZ)
2015                                 break;
2016                 }
2017         }
2018
2019         if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq,
2020                                     freq->channel, freq->ht_enabled,
2021                                     vht_freq.vht_enabled,
2022                                     freq->sec_channel_offset,
2023                                     chwidth, seg0, seg1, vht_caps) != 0)
2024                 return;
2025
2026         *freq = vht_freq;
2027
2028         wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
2029                    freq->center_freq1, freq->center_freq2, freq->bandwidth);
2030 }
2031
2032
2033 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
2034 {
2035         struct wpa_connect_work *cwork = work->ctx;
2036         struct wpa_bss *bss = cwork->bss;
2037         struct wpa_ssid *ssid = cwork->ssid;
2038         struct wpa_supplicant *wpa_s = work->wpa_s;
2039         u8 wpa_ie[200];
2040         size_t wpa_ie_len;
2041         int use_crypt, ret, i, bssid_changed;
2042         int algs = WPA_AUTH_ALG_OPEN;
2043         unsigned int cipher_pairwise, cipher_group;
2044         struct wpa_driver_associate_params params;
2045         int wep_keys_set = 0;
2046         int assoc_failed = 0;
2047         struct wpa_ssid *old_ssid;
2048 #ifdef CONFIG_HT_OVERRIDES
2049         struct ieee80211_ht_capabilities htcaps;
2050         struct ieee80211_ht_capabilities htcaps_mask;
2051 #endif /* CONFIG_HT_OVERRIDES */
2052 #ifdef CONFIG_VHT_OVERRIDES
2053        struct ieee80211_vht_capabilities vhtcaps;
2054        struct ieee80211_vht_capabilities vhtcaps_mask;
2055 #endif /* CONFIG_VHT_OVERRIDES */
2056
2057         if (deinit) {
2058                 if (work->started) {
2059                         wpa_s->connect_work = NULL;
2060
2061                         /* cancel possible auth. timeout */
2062                         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
2063                                              NULL);
2064                 }
2065                 wpas_connect_work_free(cwork);
2066                 return;
2067         }
2068
2069         wpa_s->connect_work = work;
2070
2071         if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
2072             wpas_network_disabled(wpa_s, ssid)) {
2073                 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2074                 wpas_connect_work_done(wpa_s);
2075                 return;
2076         }
2077
2078         os_memset(&params, 0, sizeof(params));
2079         wpa_s->reassociate = 0;
2080         wpa_s->eap_expected_failure = 0;
2081         if (bss &&
2082             (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
2083 #ifdef CONFIG_IEEE80211R
2084                 const u8 *ie, *md = NULL;
2085 #endif /* CONFIG_IEEE80211R */
2086                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
2087                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
2088                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
2089                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
2090                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
2091                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2092                 if (bssid_changed)
2093                         wpas_notify_bssid_changed(wpa_s);
2094 #ifdef CONFIG_IEEE80211R
2095                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
2096                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
2097                         md = ie + 2;
2098                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
2099                 if (md) {
2100                         /* Prepare for the next transition */
2101                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
2102                 }
2103 #endif /* CONFIG_IEEE80211R */
2104 #ifdef CONFIG_WPS
2105         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
2106                    wpa_s->conf->ap_scan == 2 &&
2107                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
2108                 /* Use ap_scan==1 style network selection to find the network
2109                  */
2110                 wpas_connect_work_done(wpa_s);
2111                 wpa_s->scan_req = MANUAL_SCAN_REQ;
2112                 wpa_s->reassociate = 1;
2113                 wpa_supplicant_req_scan(wpa_s, 0, 0);
2114                 return;
2115 #endif /* CONFIG_WPS */
2116         } else {
2117                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
2118                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2119                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2120         }
2121         if (!wpa_s->pno)
2122                 wpa_supplicant_cancel_sched_scan(wpa_s);
2123
2124         wpa_supplicant_cancel_scan(wpa_s);
2125
2126         /* Starting new association, so clear the possibly used WPA IE from the
2127          * previous association. */
2128         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
2129
2130 #ifdef IEEE8021X_EAPOL
2131         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2132                 if (ssid->leap) {
2133                         if (ssid->non_leap == 0)
2134                                 algs = WPA_AUTH_ALG_LEAP;
2135                         else
2136                                 algs |= WPA_AUTH_ALG_LEAP;
2137                 }
2138         }
2139 #endif /* IEEE8021X_EAPOL */
2140         wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2141         if (ssid->auth_alg) {
2142                 algs = ssid->auth_alg;
2143                 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
2144                         "0x%x", algs);
2145         }
2146
2147         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
2148                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
2149             wpa_key_mgmt_wpa(ssid->key_mgmt)) {
2150                 int try_opportunistic;
2151                 try_opportunistic = (ssid->proactive_key_caching < 0 ?
2152                                      wpa_s->conf->okc :
2153                                      ssid->proactive_key_caching) &&
2154                         (ssid->proto & WPA_PROTO_RSN);
2155                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2156                                             ssid, try_opportunistic) == 0)
2157                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2158                 wpa_ie_len = sizeof(wpa_ie);
2159                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2160                                               wpa_ie, &wpa_ie_len)) {
2161                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2162                                 "key management and encryption suites");
2163                         wpas_connect_work_done(wpa_s);
2164                         return;
2165                 }
2166         } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
2167                    wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
2168                 /*
2169                  * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2170                  * use non-WPA since the scan results did not indicate that the
2171                  * AP is using WPA or WPA2.
2172                  */
2173                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2174                 wpa_ie_len = 0;
2175                 wpa_s->wpa_proto = 0;
2176         } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
2177                 wpa_ie_len = sizeof(wpa_ie);
2178                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2179                                               wpa_ie, &wpa_ie_len)) {
2180                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2181                                 "key management and encryption suites (no "
2182                                 "scan results)");
2183                         wpas_connect_work_done(wpa_s);
2184                         return;
2185                 }
2186 #ifdef CONFIG_WPS
2187         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
2188                 struct wpabuf *wps_ie;
2189                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
2190                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
2191                         wpa_ie_len = wpabuf_len(wps_ie);
2192                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
2193                 } else
2194                         wpa_ie_len = 0;
2195                 wpabuf_free(wps_ie);
2196                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2197                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
2198                         params.wps = WPS_MODE_PRIVACY;
2199                 else
2200                         params.wps = WPS_MODE_OPEN;
2201                 wpa_s->wpa_proto = 0;
2202 #endif /* CONFIG_WPS */
2203         } else {
2204                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2205                 wpa_ie_len = 0;
2206                 wpa_s->wpa_proto = 0;
2207         }
2208
2209 #ifdef CONFIG_P2P
2210         if (wpa_s->global->p2p) {
2211                 u8 *pos;
2212                 size_t len;
2213                 int res;
2214                 pos = wpa_ie + wpa_ie_len;
2215                 len = sizeof(wpa_ie) - wpa_ie_len;
2216                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2217                                             ssid->p2p_group);
2218                 if (res >= 0)
2219                         wpa_ie_len += res;
2220         }
2221
2222         wpa_s->cross_connect_disallowed = 0;
2223         if (bss) {
2224                 struct wpabuf *p2p;
2225                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
2226                 if (p2p) {
2227                         wpa_s->cross_connect_disallowed =
2228                                 p2p_get_cross_connect_disallowed(p2p);
2229                         wpabuf_free(p2p);
2230                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2231                                 "connection",
2232                                 wpa_s->cross_connect_disallowed ?
2233                                 "disallows" : "allows");
2234                 }
2235         }
2236
2237         os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2238 #endif /* CONFIG_P2P */
2239
2240 #ifdef CONFIG_HS20
2241         if (is_hs20_network(wpa_s, ssid, bss)) {
2242                 struct wpabuf *hs20;
2243                 hs20 = wpabuf_alloc(20);
2244                 if (hs20) {
2245                         int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2246                         size_t len;
2247
2248                         wpas_hs20_add_indication(hs20, pps_mo_id);
2249                         len = sizeof(wpa_ie) - wpa_ie_len;
2250                         if (wpabuf_len(hs20) <= len) {
2251                                 os_memcpy(wpa_ie + wpa_ie_len,
2252                                           wpabuf_head(hs20), wpabuf_len(hs20));
2253                                 wpa_ie_len += wpabuf_len(hs20);
2254                         }
2255                         wpabuf_free(hs20);
2256                 }
2257         }
2258 #endif /* CONFIG_HS20 */
2259
2260         /*
2261          * Workaround: Add Extended Capabilities element only if the AP
2262          * included this element in Beacon/Probe Response frames. Some older
2263          * APs seem to have interoperability issues if this element is
2264          * included, so while the standard may require us to include the
2265          * element in all cases, it is justifiable to skip it to avoid
2266          * interoperability issues.
2267          */
2268         if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
2269                 u8 ext_capab[18];
2270                 int ext_capab_len;
2271                 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2272                                                      sizeof(ext_capab));
2273                 if (ext_capab_len > 0) {
2274                         u8 *pos = wpa_ie;
2275                         if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
2276                                 pos += 2 + pos[1];
2277                         os_memmove(pos + ext_capab_len, pos,
2278                                    wpa_ie_len - (pos - wpa_ie));
2279                         wpa_ie_len += ext_capab_len;
2280                         os_memcpy(pos, ext_capab, ext_capab_len);
2281                 }
2282         }
2283
2284         if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2285                 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2286                 size_t len;
2287
2288                 len = sizeof(wpa_ie) - wpa_ie_len;
2289                 if (wpabuf_len(buf) <= len) {
2290                         os_memcpy(wpa_ie + wpa_ie_len,
2291                                   wpabuf_head(buf), wpabuf_len(buf));
2292                         wpa_ie_len += wpabuf_len(buf);
2293                 }
2294         }
2295
2296 #ifdef CONFIG_FST
2297         if (wpa_s->fst_ies) {
2298                 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2299
2300                 if (wpa_ie_len + fst_ies_len <= sizeof(wpa_ie)) {
2301                         os_memcpy(wpa_ie + wpa_ie_len,
2302                                   wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2303                         wpa_ie_len += fst_ies_len;
2304                 }
2305         }
2306 #endif /* CONFIG_FST */
2307
2308 #ifdef CONFIG_MBO
2309         if (wpa_bss_get_vendor_ie(bss, MBO_IE_VENDOR_TYPE)) {
2310                 u8 *pos;
2311                 size_t len;
2312                 int res;
2313
2314                 pos = wpa_ie + wpa_ie_len;
2315                 len = sizeof(wpa_ie) - wpa_ie_len;
2316                 res = wpas_mbo_ie(wpa_s, pos, len);
2317                 if (res >= 0)
2318                         wpa_ie_len += res;
2319         }
2320 #endif /* CONFIG_MBO */
2321
2322         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2323         use_crypt = 1;
2324         cipher_pairwise = wpa_s->pairwise_cipher;
2325         cipher_group = wpa_s->group_cipher;
2326         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2327             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2328                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2329                         use_crypt = 0;
2330                 if (wpa_set_wep_keys(wpa_s, ssid)) {
2331                         use_crypt = 1;
2332                         wep_keys_set = 1;
2333                 }
2334         }
2335         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2336                 use_crypt = 0;
2337
2338 #ifdef IEEE8021X_EAPOL
2339         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2340                 if ((ssid->eapol_flags &
2341                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
2342                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
2343                     !wep_keys_set) {
2344                         use_crypt = 0;
2345                 } else {
2346                         /* Assume that dynamic WEP-104 keys will be used and
2347                          * set cipher suites in order for drivers to expect
2348                          * encryption. */
2349                         cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
2350                 }
2351         }
2352 #endif /* IEEE8021X_EAPOL */
2353
2354         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2355                 /* Set the key before (and later after) association */
2356                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2357         }
2358
2359         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2360         if (bss) {
2361                 params.ssid = bss->ssid;
2362                 params.ssid_len = bss->ssid_len;
2363                 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2364                         wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
2365                                    MACSTR " freq=%u MHz based on scan results "
2366                                    "(bssid_set=%d)",
2367                                    MAC2STR(bss->bssid), bss->freq,
2368                                    ssid->bssid_set);
2369                         params.bssid = bss->bssid;
2370                         params.freq.freq = bss->freq;
2371                 }
2372                 params.bssid_hint = bss->bssid;
2373                 params.freq_hint = bss->freq;
2374                 params.pbss = bss_is_pbss(bss);
2375         } else {
2376                 params.ssid = ssid->ssid;
2377                 params.ssid_len = ssid->ssid_len;
2378                 params.pbss = ssid->pbss;
2379         }
2380
2381         if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
2382             wpa_s->conf->ap_scan == 2) {
2383                 params.bssid = ssid->bssid;
2384                 params.fixed_bssid = 1;
2385         }
2386
2387         /* Initial frequency for IBSS/mesh */
2388         if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) &&
2389             ssid->frequency > 0 && params.freq.freq == 0)
2390                 ibss_mesh_setup_freq(wpa_s, ssid, &params.freq);
2391
2392         if (ssid->mode == WPAS_MODE_IBSS) {
2393                 params.fixed_freq = ssid->fixed_freq;
2394                 if (ssid->beacon_int)
2395                         params.beacon_int = ssid->beacon_int;
2396                 else
2397                         params.beacon_int = wpa_s->conf->beacon_int;
2398         }
2399
2400         params.wpa_ie = wpa_ie;
2401         params.wpa_ie_len = wpa_ie_len;
2402         params.pairwise_suite = cipher_pairwise;
2403         params.group_suite = cipher_group;
2404         params.key_mgmt_suite = wpa_s->key_mgmt;
2405         params.wpa_proto = wpa_s->wpa_proto;
2406         params.auth_alg = algs;
2407         params.mode = ssid->mode;
2408         params.bg_scan_period = ssid->bg_scan_period;
2409         for (i = 0; i < NUM_WEP_KEYS; i++) {
2410                 if (ssid->wep_key_len[i])
2411                         params.wep_key[i] = ssid->wep_key[i];
2412                 params.wep_key_len[i] = ssid->wep_key_len[i];
2413         }
2414         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
2415
2416         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2417             (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2418              params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
2419                 params.passphrase = ssid->passphrase;
2420                 if (ssid->psk_set)
2421                         params.psk = ssid->psk;
2422         }
2423
2424         if (wpa_s->conf->key_mgmt_offload) {
2425                 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
2426                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
2427                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
2428                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
2429                         params.req_key_mgmt_offload =
2430                                 ssid->proactive_key_caching < 0 ?
2431                                 wpa_s->conf->okc : ssid->proactive_key_caching;
2432                 else
2433                         params.req_key_mgmt_offload = 1;
2434
2435                 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2436                      params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
2437                      params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
2438                     ssid->psk_set)
2439                         params.psk = ssid->psk;
2440         }
2441
2442         params.drop_unencrypted = use_crypt;
2443
2444 #ifdef CONFIG_IEEE80211W
2445         params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
2446         if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
2447                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2448                 struct wpa_ie_data ie;
2449                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
2450                     ie.capabilities &
2451                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
2452                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2453                                 "MFP: require MFP");
2454                         params.mgmt_frame_protection =
2455                                 MGMT_FRAME_PROTECTION_REQUIRED;
2456                 }
2457         }
2458 #endif /* CONFIG_IEEE80211W */
2459
2460         params.p2p = ssid->p2p_group;
2461
2462         if (wpa_s->parent->set_sta_uapsd)
2463                 params.uapsd = wpa_s->parent->sta_uapsd;
2464         else
2465                 params.uapsd = -1;
2466
2467 #ifdef CONFIG_HT_OVERRIDES
2468         os_memset(&htcaps, 0, sizeof(htcaps));
2469         os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
2470         params.htcaps = (u8 *) &htcaps;
2471         params.htcaps_mask = (u8 *) &htcaps_mask;
2472         wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
2473 #endif /* CONFIG_HT_OVERRIDES */
2474 #ifdef CONFIG_VHT_OVERRIDES
2475         os_memset(&vhtcaps, 0, sizeof(vhtcaps));
2476         os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
2477         params.vhtcaps = &vhtcaps;
2478         params.vhtcaps_mask = &vhtcaps_mask;
2479         wpa_supplicant_apply_vht_overrides(wpa_s, ssid, &params);
2480 #endif /* CONFIG_VHT_OVERRIDES */
2481
2482 #ifdef CONFIG_P2P
2483         /*
2484          * If multi-channel concurrency is not supported, check for any
2485          * frequency conflict. In case of any frequency conflict, remove the
2486          * least prioritized connection.
2487          */
2488         if (wpa_s->num_multichan_concurrent < 2) {
2489                 int freq, num;
2490                 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2491                 if (num > 0 && freq > 0 && freq != params.freq.freq) {
2492                         wpa_printf(MSG_DEBUG,
2493                                    "Assoc conflicting freq found (%d != %d)",
2494                                    freq, params.freq.freq);
2495                         if (wpas_p2p_handle_frequency_conflicts(
2496                                     wpa_s, params.freq.freq, ssid) < 0) {
2497                                 wpas_connect_work_done(wpa_s);
2498                                 return;
2499                         }
2500                 }
2501         }
2502 #endif /* CONFIG_P2P */
2503
2504         ret = wpa_drv_associate(wpa_s, &params);
2505         if (ret < 0) {
2506                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2507                         "failed");
2508                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2509                         /*
2510                          * The driver is known to mean what is saying, so we
2511                          * can stop right here; the association will not
2512                          * succeed.
2513                          */
2514                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2515                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2516                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2517                         return;
2518                 }
2519                 /* try to continue anyway; new association will be tried again
2520                  * after timeout */
2521                 assoc_failed = 1;
2522         }
2523
2524         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2525                 /* Set the key after the association just in case association
2526                  * cleared the previously configured key. */
2527                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2528                 /* No need to timeout authentication since there is no key
2529                  * management. */
2530                 wpa_supplicant_cancel_auth_timeout(wpa_s);
2531                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2532 #ifdef CONFIG_IBSS_RSN
2533         } else if (ssid->mode == WPAS_MODE_IBSS &&
2534                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2535                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2536                 /*
2537                  * RSN IBSS authentication is per-STA and we can disable the
2538                  * per-BSSID authentication.
2539                  */
2540                 wpa_supplicant_cancel_auth_timeout(wpa_s);
2541 #endif /* CONFIG_IBSS_RSN */
2542         } else {
2543                 /* Timeout for IEEE 802.11 authentication and association */
2544                 int timeout = 60;
2545
2546                 if (assoc_failed) {
2547                         /* give IBSS a bit more time */
2548                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2549                 } else if (wpa_s->conf->ap_scan == 1) {
2550                         /* give IBSS a bit more time */
2551                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2552                 }
2553                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2554         }
2555
2556         if (wep_keys_set &&
2557             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2558                 /* Set static WEP keys again */
2559                 wpa_set_wep_keys(wpa_s, ssid);
2560         }
2561
2562         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2563                 /*
2564                  * Do not allow EAP session resumption between different
2565                  * network configurations.
2566                  */
2567                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2568         }
2569         old_ssid = wpa_s->current_ssid;
2570         wpa_s->current_ssid = ssid;
2571         if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set)
2572                 wpa_s->current_bss = bss;
2573         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2574         wpa_supplicant_initiate_eapol(wpa_s);
2575         if (old_ssid != wpa_s->current_ssid)
2576                 wpas_notify_network_changed(wpa_s);
2577 }
2578
2579
2580 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2581                                             const u8 *addr)
2582 {
2583         struct wpa_ssid *old_ssid;
2584
2585         wpas_connect_work_done(wpa_s);
2586         wpa_clear_keys(wpa_s, addr);
2587         old_ssid = wpa_s->current_ssid;
2588         wpa_supplicant_mark_disassoc(wpa_s);
2589         wpa_sm_set_config(wpa_s->wpa, NULL);
2590         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2591         if (old_ssid != wpa_s->current_ssid)
2592                 wpas_notify_network_changed(wpa_s);
2593         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2594 }
2595
2596
2597 /**
2598  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2599  * @wpa_s: Pointer to wpa_supplicant data
2600  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2601  *
2602  * This function is used to request %wpa_supplicant to deauthenticate from the
2603  * current AP.
2604  */
2605 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2606                                    int reason_code)
2607 {
2608         u8 *addr = NULL;
2609         union wpa_event_data event;
2610         int zero_addr = 0;
2611
2612         wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2613                 " pending_bssid=" MACSTR " reason=%d state=%s",
2614                 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2615                 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2616
2617         if (!is_zero_ether_addr(wpa_s->bssid))
2618                 addr = wpa_s->bssid;
2619         else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2620                  (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2621                   wpa_s->wpa_state == WPA_ASSOCIATING))
2622                 addr = wpa_s->pending_bssid;
2623         else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2624                 /*
2625                  * When using driver-based BSS selection, we may not know the
2626                  * BSSID with which we are currently trying to associate. We
2627                  * need to notify the driver of this disconnection even in such
2628                  * a case, so use the all zeros address here.
2629                  */
2630                 addr = wpa_s->bssid;
2631                 zero_addr = 1;
2632         }
2633
2634 #ifdef CONFIG_TDLS
2635         wpa_tdls_teardown_peers(wpa_s->wpa);
2636 #endif /* CONFIG_TDLS */
2637
2638 #ifdef CONFIG_MESH
2639         if (wpa_s->ifmsh) {
2640                 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
2641                         wpa_s->ifname);
2642                 wpa_supplicant_leave_mesh(wpa_s);
2643         }
2644 #endif /* CONFIG_MESH */
2645
2646         if (addr) {
2647                 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2648                 os_memset(&event, 0, sizeof(event));
2649                 event.deauth_info.reason_code = (u16) reason_code;
2650                 event.deauth_info.locally_generated = 1;
2651                 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2652                 if (zero_addr)
2653                         addr = NULL;
2654         }
2655
2656         wpa_supplicant_clear_connection(wpa_s, addr);
2657 }
2658
2659 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2660                                               struct wpa_ssid *ssid)
2661 {
2662         if (!ssid || !ssid->disabled || ssid->disabled == 2)
2663                 return;
2664
2665         ssid->disabled = 0;
2666         wpas_clear_temp_disabled(wpa_s, ssid, 1);
2667         wpas_notify_network_enabled_changed(wpa_s, ssid);
2668
2669         /*
2670          * Try to reassociate since there is no current configuration and a new
2671          * network was made available.
2672          */
2673         if (!wpa_s->current_ssid && !wpa_s->disconnected)
2674                 wpa_s->reassociate = 1;
2675 }
2676
2677
2678 /**
2679  * wpa_supplicant_enable_network - Mark a configured network as enabled
2680  * @wpa_s: wpa_supplicant structure for a network interface
2681  * @ssid: wpa_ssid structure for a configured network or %NULL
2682  *
2683  * Enables the specified network or all networks if no network specified.
2684  */
2685 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2686                                    struct wpa_ssid *ssid)
2687 {
2688         if (ssid == NULL) {
2689                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2690                         wpa_supplicant_enable_one_network(wpa_s, ssid);
2691         } else
2692                 wpa_supplicant_enable_one_network(wpa_s, ssid);
2693
2694         if (wpa_s->reassociate && !wpa_s->disconnected &&
2695             (!wpa_s->current_ssid ||
2696              wpa_s->wpa_state == WPA_DISCONNECTED ||
2697              wpa_s->wpa_state == WPA_SCANNING)) {
2698                 if (wpa_s->sched_scanning) {
2699                         wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2700                                    "new network to scan filters");
2701                         wpa_supplicant_cancel_sched_scan(wpa_s);
2702                 }
2703
2704                 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
2705                         wpa_s->scan_req = NORMAL_SCAN_REQ;
2706                         wpa_supplicant_req_scan(wpa_s, 0, 0);
2707                 }
2708         }
2709 }
2710
2711
2712 /**
2713  * wpa_supplicant_disable_network - Mark a configured network as disabled
2714  * @wpa_s: wpa_supplicant structure for a network interface
2715  * @ssid: wpa_ssid structure for a configured network or %NULL
2716  *
2717  * Disables the specified network or all networks if no network specified.
2718  */
2719 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2720                                     struct wpa_ssid *ssid)
2721 {
2722         struct wpa_ssid *other_ssid;
2723         int was_disabled;
2724
2725         if (ssid == NULL) {
2726                 if (wpa_s->sched_scanning)
2727                         wpa_supplicant_cancel_sched_scan(wpa_s);
2728
2729                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2730                      other_ssid = other_ssid->next) {
2731                         was_disabled = other_ssid->disabled;
2732                         if (was_disabled == 2)
2733                                 continue; /* do not change persistent P2P group
2734                                            * data */
2735
2736                         other_ssid->disabled = 1;
2737
2738                         if (was_disabled != other_ssid->disabled)
2739                                 wpas_notify_network_enabled_changed(
2740                                         wpa_s, other_ssid);
2741                 }
2742                 if (wpa_s->current_ssid)
2743                         wpa_supplicant_deauthenticate(
2744                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2745         } else if (ssid->disabled != 2) {
2746                 if (ssid == wpa_s->current_ssid)
2747                         wpa_supplicant_deauthenticate(
2748                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2749
2750                 was_disabled = ssid->disabled;
2751
2752                 ssid->disabled = 1;
2753
2754                 if (was_disabled != ssid->disabled) {
2755                         wpas_notify_network_enabled_changed(wpa_s, ssid);
2756                         if (wpa_s->sched_scanning) {
2757                                 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2758                                            "to remove network from filters");
2759                                 wpa_supplicant_cancel_sched_scan(wpa_s);
2760                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
2761                         }
2762                 }
2763         }
2764 }
2765
2766
2767 /**
2768  * wpa_supplicant_select_network - Attempt association with a network
2769  * @wpa_s: wpa_supplicant structure for a network interface
2770  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2771  */
2772 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2773                                    struct wpa_ssid *ssid)
2774 {
2775
2776         struct wpa_ssid *other_ssid;
2777         int disconnected = 0;
2778
2779         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2780                 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2781                         wpa_s->own_disconnect_req = 1;
2782                 wpa_supplicant_deauthenticate(
2783                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2784                 disconnected = 1;
2785         }
2786
2787         if (ssid)
2788                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2789
2790         /*
2791          * Mark all other networks disabled or mark all networks enabled if no
2792          * network specified.
2793          */
2794         for (other_ssid = wpa_s->conf->ssid; other_ssid;
2795              other_ssid = other_ssid->next) {
2796                 int was_disabled = other_ssid->disabled;
2797                 if (was_disabled == 2)
2798                         continue; /* do not change persistent P2P group data */
2799
2800                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
2801                 if (was_disabled && !other_ssid->disabled)
2802                         wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2803
2804                 if (was_disabled != other_ssid->disabled)
2805                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2806         }
2807
2808         if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
2809             wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2810                 /* We are already associated with the selected network */
2811                 wpa_printf(MSG_DEBUG, "Already associated with the "
2812                            "selected network - do nothing");
2813                 return;
2814         }
2815
2816         if (ssid) {
2817                 wpa_s->current_ssid = ssid;
2818                 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2819                 wpa_s->connect_without_scan =
2820                         (ssid->mode == WPAS_MODE_MESH) ? ssid : NULL;
2821
2822                 /*
2823                  * Don't optimize next scan freqs since a new ESS has been
2824                  * selected.
2825                  */
2826                 os_free(wpa_s->next_scan_freqs);
2827                 wpa_s->next_scan_freqs = NULL;
2828         } else {
2829                 wpa_s->connect_without_scan = NULL;
2830         }
2831
2832         wpa_s->disconnected = 0;
2833         wpa_s->reassociate = 1;
2834
2835         if (wpa_s->connect_without_scan ||
2836             wpa_supplicant_fast_associate(wpa_s) != 1) {
2837                 wpa_s->scan_req = NORMAL_SCAN_REQ;
2838                 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
2839         }
2840
2841         if (ssid)
2842                 wpas_notify_network_selected(wpa_s, ssid);
2843 }
2844
2845
2846 /**
2847  * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
2848  * @wpa_s: wpa_supplicant structure for a network interface
2849  * @pkcs11_engine_path: PKCS #11 engine path or NULL
2850  * @pkcs11_module_path: PKCS #11 module path or NULL
2851  * Returns: 0 on success; -1 on failure
2852  *
2853  * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
2854  * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
2855  * module path fails the paths will be reset to the default value (NULL).
2856  */
2857 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2858                                            const char *pkcs11_engine_path,
2859                                            const char *pkcs11_module_path)
2860 {
2861         char *pkcs11_engine_path_copy = NULL;
2862         char *pkcs11_module_path_copy = NULL;
2863
2864         if (pkcs11_engine_path != NULL) {
2865                 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
2866                 if (pkcs11_engine_path_copy == NULL)
2867                         return -1;
2868         }
2869         if (pkcs11_module_path != NULL) {
2870                 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
2871                 if (pkcs11_module_path_copy == NULL) {
2872                         os_free(pkcs11_engine_path_copy);
2873                         return -1;
2874                 }
2875         }
2876
2877         os_free(wpa_s->conf->pkcs11_engine_path);
2878         os_free(wpa_s->conf->pkcs11_module_path);
2879         wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2880         wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2881
2882         wpa_sm_set_eapol(wpa_s->wpa, NULL);
2883         eapol_sm_deinit(wpa_s->eapol);
2884         wpa_s->eapol = NULL;
2885         if (wpa_supplicant_init_eapol(wpa_s)) {
2886                 /* Error -> Reset paths to the default value (NULL) once. */
2887                 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
2888                         wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2889                                                                NULL);
2890
2891                 return -1;
2892         }
2893         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2894
2895         return 0;
2896 }
2897
2898
2899 /**
2900  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2901  * @wpa_s: wpa_supplicant structure for a network interface
2902  * @ap_scan: AP scan mode
2903  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2904  *
2905  */
2906 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2907 {
2908
2909         int old_ap_scan;
2910
2911         if (ap_scan < 0 || ap_scan > 2)
2912                 return -1;
2913
2914         if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
2915                 wpa_printf(MSG_INFO,
2916                            "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
2917         }
2918
2919 #ifdef ANDROID
2920         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2921             wpa_s->wpa_state >= WPA_ASSOCIATING &&
2922             wpa_s->wpa_state < WPA_COMPLETED) {
2923                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
2924                            "associating", wpa_s->conf->ap_scan, ap_scan);
2925                 return 0;
2926         }
2927 #endif /* ANDROID */
2928
2929         old_ap_scan = wpa_s->conf->ap_scan;
2930         wpa_s->conf->ap_scan = ap_scan;
2931
2932         if (old_ap_scan != wpa_s->conf->ap_scan)
2933                 wpas_notify_ap_scan_changed(wpa_s);
2934
2935         return 0;
2936 }
2937
2938
2939 /**
2940  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
2941  * @wpa_s: wpa_supplicant structure for a network interface
2942  * @expire_age: Expiration age in seconds
2943  * Returns: 0 if succeed or -1 if expire_age has an invalid value
2944  *
2945  */
2946 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2947                                           unsigned int bss_expire_age)
2948 {
2949         if (bss_expire_age < 10) {
2950                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2951                         bss_expire_age);
2952                 return -1;
2953         }
2954         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2955                 bss_expire_age);
2956         wpa_s->conf->bss_expiration_age = bss_expire_age;
2957
2958         return 0;
2959 }
2960
2961
2962 /**
2963  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
2964  * @wpa_s: wpa_supplicant structure for a network interface
2965  * @expire_count: number of scans after which an unseen BSS is reclaimed
2966  * Returns: 0 if succeed or -1 if expire_count has an invalid value
2967  *
2968  */
2969 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2970                                             unsigned int bss_expire_count)
2971 {
2972         if (bss_expire_count < 1) {
2973                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2974                         bss_expire_count);
2975                 return -1;
2976         }
2977         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2978                 bss_expire_count);
2979         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2980
2981         return 0;
2982 }
2983
2984
2985 /**
2986  * wpa_supplicant_set_scan_interval - Set scan interval
2987  * @wpa_s: wpa_supplicant structure for a network interface
2988  * @scan_interval: scan interval in seconds
2989  * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2990  *
2991  */
2992 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2993                                      int scan_interval)
2994 {
2995         if (scan_interval < 0) {
2996                 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2997                         scan_interval);
2998                 return -1;
2999         }
3000         wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3001                 scan_interval);
3002         wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3003
3004         return 0;
3005 }
3006
3007
3008 /**
3009  * wpa_supplicant_set_debug_params - Set global debug params
3010  * @global: wpa_global structure
3011  * @debug_level: debug level
3012  * @debug_timestamp: determines if show timestamp in debug data
3013  * @debug_show_keys: determines if show keys in debug data
3014  * Returns: 0 if succeed or -1 if debug_level has wrong value
3015  */
3016 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
3017                                     int debug_timestamp, int debug_show_keys)
3018 {
3019
3020         int old_level, old_timestamp, old_show_keys;
3021
3022         /* check for allowed debuglevels */
3023         if (debug_level != MSG_EXCESSIVE &&
3024             debug_level != MSG_MSGDUMP &&
3025             debug_level != MSG_DEBUG &&
3026             debug_level != MSG_INFO &&
3027             debug_level != MSG_WARNING &&
3028             debug_level != MSG_ERROR)
3029                 return -1;
3030
3031         old_level = wpa_debug_level;
3032         old_timestamp = wpa_debug_timestamp;
3033         old_show_keys = wpa_debug_show_keys;
3034
3035         wpa_debug_level = debug_level;
3036         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
3037         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
3038
3039         if (wpa_debug_level != old_level)
3040                 wpas_notify_debug_level_changed(global);
3041         if (wpa_debug_timestamp != old_timestamp)
3042                 wpas_notify_debug_timestamp_changed(global);
3043         if (wpa_debug_show_keys != old_show_keys)
3044                 wpas_notify_debug_show_keys_changed(global);
3045
3046         return 0;
3047 }
3048
3049
3050 /**
3051  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
3052  * @wpa_s: Pointer to wpa_supplicant data
3053  * Returns: A pointer to the current network structure or %NULL on failure
3054  */
3055 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
3056 {
3057         struct wpa_ssid *entry;
3058         u8 ssid[SSID_MAX_LEN];
3059         int res;
3060         size_t ssid_len;
3061         u8 bssid[ETH_ALEN];
3062         int wired;
3063
3064         res = wpa_drv_get_ssid(wpa_s, ssid);
3065         if (res < 0) {
3066                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
3067                         "driver");
3068                 return NULL;
3069         }
3070         ssid_len = res;
3071
3072         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
3073                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
3074                         "driver");
3075                 return NULL;
3076         }
3077
3078         wired = wpa_s->conf->ap_scan == 0 &&
3079                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
3080
3081         entry = wpa_s->conf->ssid;
3082         while (entry) {
3083                 if (!wpas_network_disabled(wpa_s, entry) &&
3084                     ((ssid_len == entry->ssid_len &&
3085                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
3086                     (!entry->bssid_set ||
3087                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3088                         return entry;
3089 #ifdef CONFIG_WPS
3090                 if (!wpas_network_disabled(wpa_s, entry) &&
3091                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
3092                     (entry->ssid == NULL || entry->ssid_len == 0) &&
3093                     (!entry->bssid_set ||
3094                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3095                         return entry;
3096 #endif /* CONFIG_WPS */
3097
3098                 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
3099                     entry->ssid_len == 0 &&
3100                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
3101                         return entry;
3102
3103                 entry = entry->next;
3104         }
3105
3106         return NULL;
3107 }
3108
3109
3110 static int select_driver(struct wpa_supplicant *wpa_s, int i)
3111 {
3112         struct wpa_global *global = wpa_s->global;
3113
3114         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
3115                 global->drv_priv[i] = wpa_drivers[i]->global_init();
3116                 if (global->drv_priv[i] == NULL) {
3117                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
3118                                    "'%s'", wpa_drivers[i]->name);
3119                         return -1;
3120                 }
3121         }
3122
3123         wpa_s->driver = wpa_drivers[i];
3124         wpa_s->global_drv_priv = global->drv_priv[i];
3125
3126         return 0;
3127 }
3128
3129
3130 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
3131                                      const char *name)
3132 {
3133         int i;
3134         size_t len;
3135         const char *pos, *driver = name;
3136
3137         if (wpa_s == NULL)
3138                 return -1;
3139
3140         if (wpa_drivers[0] == NULL) {
3141                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
3142                         "wpa_supplicant");
3143                 return -1;
3144         }
3145
3146         if (name == NULL) {
3147                 /* default to first driver in the list */
3148                 return select_driver(wpa_s, 0);
3149         }
3150
3151         do {
3152                 pos = os_strchr(driver, ',');
3153                 if (pos)
3154                         len = pos - driver;
3155                 else
3156                         len = os_strlen(driver);
3157
3158                 for (i = 0; wpa_drivers[i]; i++) {
3159                         if (os_strlen(wpa_drivers[i]->name) == len &&
3160                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
3161                             0) {
3162                                 /* First driver that succeeds wins */
3163                                 if (select_driver(wpa_s, i) == 0)
3164                                         return 0;
3165                         }
3166                 }
3167
3168                 driver = pos + 1;
3169         } while (pos);
3170
3171         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
3172         return -1;
3173 }
3174
3175
3176 /**
3177  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
3178  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3179  *      with struct wpa_driver_ops::init()
3180  * @src_addr: Source address of the EAPOL frame
3181  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3182  * @len: Length of the EAPOL data
3183  *
3184  * This function is called for each received EAPOL frame. Most driver
3185  * interfaces rely on more generic OS mechanism for receiving frames through
3186  * l2_packet, but if such a mechanism is not available, the driver wrapper may
3187  * take care of received EAPOL frames and deliver them to the core supplicant
3188  * code by calling this function.
3189  */
3190 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
3191                              const u8 *buf, size_t len)
3192 {
3193         struct wpa_supplicant *wpa_s = ctx;
3194
3195         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3196         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
3197
3198 #ifdef CONFIG_PEERKEY
3199         if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
3200             wpa_s->current_ssid->peerkey &&
3201             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
3202             wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
3203                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
3204                 return;
3205         }
3206 #endif /* CONFIG_PEERKEY */
3207
3208         if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3209             (wpa_s->last_eapol_matches_bssid &&
3210 #ifdef CONFIG_AP
3211              !wpa_s->ap_iface &&
3212 #endif /* CONFIG_AP */
3213              os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3214                 /*
3215                  * There is possible race condition between receiving the
3216                  * association event and the EAPOL frame since they are coming
3217                  * through different paths from the driver. In order to avoid
3218                  * issues in trying to process the EAPOL frame before receiving
3219                  * association information, lets queue it for processing until
3220                  * the association event is received. This may also be needed in
3221                  * driver-based roaming case, so also use src_addr != BSSID as a
3222                  * trigger if we have previously confirmed that the
3223                  * Authenticator uses BSSID as the src_addr (which is not the
3224                  * case with wired IEEE 802.1X).
3225                  */
3226                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3227                         "of received EAPOL frame (state=%s bssid=" MACSTR ")",
3228                         wpa_supplicant_state_txt(wpa_s->wpa_state),
3229                         MAC2STR(wpa_s->bssid));
3230                 wpabuf_free(wpa_s->pending_eapol_rx);
3231                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3232                 if (wpa_s->pending_eapol_rx) {
3233                         os_get_reltime(&wpa_s->pending_eapol_rx_time);
3234                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3235                                   ETH_ALEN);
3236                 }
3237                 return;
3238         }
3239
3240         wpa_s->last_eapol_matches_bssid =
3241                 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3242
3243 #ifdef CONFIG_AP
3244         if (wpa_s->ap_iface) {
3245                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3246                 return;
3247         }
3248 #endif /* CONFIG_AP */
3249
3250         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3251                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3252                         "no key management is configured");
3253                 return;
3254         }
3255
3256         if (wpa_s->eapol_received == 0 &&
3257             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3258              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3259              wpa_s->wpa_state != WPA_COMPLETED) &&
3260             (wpa_s->current_ssid == NULL ||
3261              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3262                 /* Timeout for completing IEEE 802.1X and WPA authentication */
3263                 int timeout = 10;
3264
3265                 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3266                     wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3267                     wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3268                         /* Use longer timeout for IEEE 802.1X/EAP */
3269                         timeout = 70;
3270                 }
3271
3272 #ifdef CONFIG_WPS
3273                 if (wpa_s->current_ssid && wpa_s->current_bss &&
3274                     (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3275                     eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3276                         /*
3277                          * Use shorter timeout if going through WPS AP iteration
3278                          * for PIN config method with an AP that does not
3279                          * advertise Selected Registrar.
3280                          */
3281                         struct wpabuf *wps_ie;
3282
3283                         wps_ie = wpa_bss_get_vendor_ie_multi(
3284                                 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3285                         if (wps_ie &&
3286                             !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3287                                 timeout = 10;
3288                         wpabuf_free(wps_ie);
3289                 }
3290 #endif /* CONFIG_WPS */
3291
3292                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3293         }
3294         wpa_s->eapol_received++;
3295
3296         if (wpa_s->countermeasures) {
3297                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3298                         "EAPOL packet");
3299                 return;
3300         }
3301
3302 #ifdef CONFIG_IBSS_RSN
3303         if (wpa_s->current_ssid &&
3304             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3305                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3306                 return;
3307         }
3308 #endif /* CONFIG_IBSS_RSN */
3309
3310         /* Source address of the incoming EAPOL frame could be compared to the
3311          * current BSSID. However, it is possible that a centralized
3312          * Authenticator could be using another MAC address than the BSSID of
3313          * an AP, so just allow any address to be used for now. The replies are
3314          * still sent to the current BSSID (if available), though. */
3315
3316         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3317         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3318             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3319                 return;
3320         wpa_drv_poll(wpa_s);
3321         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3322                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3323         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3324                 /*
3325                  * Set portValid = TRUE here since we are going to skip 4-way
3326                  * handshake processing which would normally set portValid. We
3327                  * need this to allow the EAPOL state machines to be completed
3328                  * without going through EAPOL-Key handshake.
3329                  */
3330                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3331         }
3332 }
3333
3334
3335 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3336 {
3337         if ((!wpa_s->p2p_mgmt ||
3338              !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3339             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3340                 l2_packet_deinit(wpa_s->l2);
3341                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3342                                            wpa_drv_get_mac_addr(wpa_s),
3343                                            ETH_P_EAPOL,
3344                                            wpa_supplicant_rx_eapol, wpa_s, 0);
3345                 if (wpa_s->l2 == NULL)
3346                         return -1;
3347         } else {
3348                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3349                 if (addr)
3350                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3351         }
3352
3353         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3354                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3355                 return -1;
3356         }
3357
3358         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3359
3360         return 0;
3361 }
3362
3363
3364 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
3365                                            const u8 *buf, size_t len)
3366 {
3367         struct wpa_supplicant *wpa_s = ctx;
3368         const struct l2_ethhdr *eth;
3369
3370         if (len < sizeof(*eth))
3371                 return;
3372         eth = (const struct l2_ethhdr *) buf;
3373
3374         if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3375             !(eth->h_dest[0] & 0x01)) {
3376                 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3377                         " (bridge - not for this interface - ignore)",
3378                         MAC2STR(src_addr), MAC2STR(eth->h_dest));
3379                 return;
3380         }
3381
3382         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3383                 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
3384         wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
3385                                 len - sizeof(*eth));
3386 }
3387
3388
3389 /**
3390  * wpa_supplicant_driver_init - Initialize driver interface parameters
3391  * @wpa_s: Pointer to wpa_supplicant data
3392  * Returns: 0 on success, -1 on failure
3393  *
3394  * This function is called to initialize driver interface parameters.
3395  * wpa_drv_init() must have been called before this function to initialize the
3396  * driver interface.
3397  */
3398 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
3399 {
3400         static int interface_count = 0;
3401
3402         if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
3403                 return -1;
3404
3405         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
3406                 MAC2STR(wpa_s->own_addr));
3407         os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
3408         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3409
3410         if (wpa_s->bridge_ifname[0]) {
3411                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
3412                         "interface '%s'", wpa_s->bridge_ifname);
3413                 wpa_s->l2_br = l2_packet_init_bridge(
3414                         wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
3415                         ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
3416                 if (wpa_s->l2_br == NULL) {
3417                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
3418                                 "connection for the bridge interface '%s'",
3419                                 wpa_s->bridge_ifname);
3420                         return -1;
3421                 }
3422         }
3423
3424         if (wpa_s->conf->ap_scan == 2 &&
3425             os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3426                 wpa_printf(MSG_INFO,
3427                            "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3428         }
3429
3430         wpa_clear_keys(wpa_s, NULL);
3431
3432         /* Make sure that TKIP countermeasures are not left enabled (could
3433          * happen if wpa_supplicant is killed during countermeasures. */
3434         wpa_drv_set_countermeasures(wpa_s, 0);
3435
3436         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
3437         wpa_drv_flush_pmkid(wpa_s);
3438
3439         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
3440         wpa_s->prev_scan_wildcard = 0;
3441
3442         if (wpa_supplicant_enabled_networks(wpa_s)) {
3443                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
3444                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3445                         interface_count = 0;
3446                 }
3447 #ifndef ANDROID
3448                 if (!wpa_s->p2p_mgmt &&
3449                     wpa_supplicant_delayed_sched_scan(wpa_s,
3450                                                       interface_count % 3,
3451                                                       100000))
3452                         wpa_supplicant_req_scan(wpa_s, interface_count % 3,
3453                                                 100000);
3454 #endif /* ANDROID */
3455                 interface_count++;
3456         } else
3457                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
3458
3459         return 0;
3460 }
3461
3462
3463 static int wpa_supplicant_daemon(const char *pid_file)
3464 {
3465         wpa_printf(MSG_DEBUG, "Daemonize..");
3466         return os_daemonize(pid_file);
3467 }
3468
3469
3470 static struct wpa_supplicant *
3471 wpa_supplicant_alloc(struct wpa_supplicant *parent)
3472 {
3473         struct wpa_supplicant *wpa_s;
3474
3475         wpa_s = os_zalloc(sizeof(*wpa_s));
3476         if (wpa_s == NULL)
3477                 return NULL;
3478         wpa_s->scan_req = INITIAL_SCAN_REQ;
3479         wpa_s->scan_interval = 5;
3480         wpa_s->new_connection = 1;
3481         wpa_s->parent = parent ? parent : wpa_s;
3482         wpa_s->sched_scanning = 0;
3483
3484         return wpa_s;
3485 }
3486
3487
3488 #ifdef CONFIG_HT_OVERRIDES
3489
3490 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
3491                              struct ieee80211_ht_capabilities *htcaps,
3492                              struct ieee80211_ht_capabilities *htcaps_mask,
3493                              const char *ht_mcs)
3494 {
3495         /* parse ht_mcs into hex array */
3496         int i;
3497         const char *tmp = ht_mcs;
3498         char *end = NULL;
3499
3500         /* If ht_mcs is null, do not set anything */
3501         if (!ht_mcs)
3502                 return 0;
3503
3504         /* This is what we are setting in the kernel */
3505         os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
3506
3507         wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
3508
3509         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3510                 errno = 0;
3511                 long v = strtol(tmp, &end, 16);
3512                 if (errno == 0) {
3513                         wpa_msg(wpa_s, MSG_DEBUG,
3514                                 "htcap value[%i]: %ld end: %p  tmp: %p",
3515                                 i, v, end, tmp);
3516                         if (end == tmp)
3517                                 break;
3518
3519                         htcaps->supported_mcs_set[i] = v;
3520                         tmp = end;
3521                 } else {
3522                         wpa_msg(wpa_s, MSG_ERROR,
3523                                 "Failed to parse ht-mcs: %s, error: %s\n",
3524                                 ht_mcs, strerror(errno));
3525                         return -1;
3526                 }
3527         }
3528
3529         /*
3530          * If we were able to parse any values, then set mask for the MCS set.
3531          */
3532         if (i) {
3533                 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
3534                           IEEE80211_HT_MCS_MASK_LEN - 1);
3535                 /* skip the 3 reserved bits */
3536                 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
3537                         0x1f;
3538         }
3539
3540         return 0;
3541 }
3542
3543
3544 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
3545                                  struct ieee80211_ht_capabilities *htcaps,
3546                                  struct ieee80211_ht_capabilities *htcaps_mask,
3547                                  int disabled)
3548 {
3549         le16 msk;
3550
3551         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3552
3553         if (disabled == -1)
3554                 return 0;
3555
3556         msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3557         htcaps_mask->ht_capabilities_info |= msk;
3558         if (disabled)
3559                 htcaps->ht_capabilities_info &= msk;
3560         else
3561                 htcaps->ht_capabilities_info |= msk;
3562
3563         return 0;
3564 }
3565
3566
3567 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3568                                 struct ieee80211_ht_capabilities *htcaps,
3569                                 struct ieee80211_ht_capabilities *htcaps_mask,
3570                                 int factor)
3571 {
3572         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3573
3574         if (factor == -1)
3575                 return 0;
3576
3577         if (factor < 0 || factor > 3) {
3578                 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3579                         "Must be 0-3 or -1", factor);
3580                 return -EINVAL;
3581         }
3582
3583         htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3584         htcaps->a_mpdu_params &= ~0x3;
3585         htcaps->a_mpdu_params |= factor & 0x3;
3586
3587         return 0;
3588 }
3589
3590
3591 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3592                                  struct ieee80211_ht_capabilities *htcaps,
3593                                  struct ieee80211_ht_capabilities *htcaps_mask,
3594                                  int density)
3595 {
3596         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3597
3598         if (density == -1)
3599                 return 0;
3600
3601         if (density < 0 || density > 7) {
3602                 wpa_msg(wpa_s, MSG_ERROR,
3603                         "ampdu_density: %d out of range. Must be 0-7 or -1.",
3604                         density);
3605                 return -EINVAL;
3606         }
3607
3608         htcaps_mask->a_mpdu_params |= 0x1C;
3609         htcaps->a_mpdu_params &= ~(0x1C);
3610         htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3611
3612         return 0;
3613 }
3614
3615
3616 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3617                                 struct ieee80211_ht_capabilities *htcaps,
3618                                 struct ieee80211_ht_capabilities *htcaps_mask,
3619                                 int disabled)
3620 {
3621         /* Masking these out disables HT40 */
3622         le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3623                                 HT_CAP_INFO_SHORT_GI40MHZ);
3624
3625         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3626
3627         if (disabled)
3628                 htcaps->ht_capabilities_info &= ~msk;
3629         else
3630                 htcaps->ht_capabilities_info |= msk;
3631
3632         htcaps_mask->ht_capabilities_info |= msk;
3633
3634         return 0;
3635 }
3636
3637
3638 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3639                                struct ieee80211_ht_capabilities *htcaps,
3640                                struct ieee80211_ht_capabilities *htcaps_mask,
3641                                int disabled)
3642 {
3643         /* Masking these out disables SGI */
3644         le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3645                                 HT_CAP_INFO_SHORT_GI40MHZ);
3646
3647         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3648
3649         if (disabled)
3650                 htcaps->ht_capabilities_info &= ~msk;
3651         else
3652                 htcaps->ht_capabilities_info |= msk;
3653
3654         htcaps_mask->ht_capabilities_info |= msk;
3655
3656         return 0;
3657 }
3658
3659
3660 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3661                                struct ieee80211_ht_capabilities *htcaps,
3662                                struct ieee80211_ht_capabilities *htcaps_mask,
3663                                int disabled)
3664 {
3665         /* Masking these out disables LDPC */
3666         le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
3667
3668         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3669
3670         if (disabled)
3671                 htcaps->ht_capabilities_info &= ~msk;
3672         else
3673                 htcaps->ht_capabilities_info |= msk;
3674
3675         htcaps_mask->ht_capabilities_info |= msk;
3676
3677         return 0;
3678 }
3679
3680
3681 void wpa_supplicant_apply_ht_overrides(
3682         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3683         struct wpa_driver_associate_params *params)
3684 {
3685         struct ieee80211_ht_capabilities *htcaps;
3686         struct ieee80211_ht_capabilities *htcaps_mask;
3687
3688         if (!ssid)
3689                 return;
3690
3691         params->disable_ht = ssid->disable_ht;
3692         if (!params->htcaps || !params->htcaps_mask)
3693                 return;
3694
3695         htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3696         htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3697         wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3698         wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3699                               ssid->disable_max_amsdu);
3700         wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3701         wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3702         wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3703         wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3704         wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3705
3706         if (ssid->ht40_intolerant) {
3707                 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
3708                 htcaps->ht_capabilities_info |= bit;
3709                 htcaps_mask->ht_capabilities_info |= bit;
3710         }
3711 }
3712
3713 #endif /* CONFIG_HT_OVERRIDES */
3714
3715
3716 #ifdef CONFIG_VHT_OVERRIDES
3717 void wpa_supplicant_apply_vht_overrides(
3718         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3719         struct wpa_driver_associate_params *params)
3720 {
3721         struct ieee80211_vht_capabilities *vhtcaps;
3722         struct ieee80211_vht_capabilities *vhtcaps_mask;
3723
3724         if (!ssid)
3725                 return;
3726
3727         params->disable_vht = ssid->disable_vht;
3728
3729         vhtcaps = (void *) params->vhtcaps;
3730         vhtcaps_mask = (void *) params->vhtcaps_mask;
3731
3732         if (!vhtcaps || !vhtcaps_mask)
3733                 return;
3734
3735         vhtcaps->vht_capabilities_info = ssid->vht_capa;
3736         vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
3737
3738 #ifdef CONFIG_HT_OVERRIDES
3739         /* if max ampdu is <= 3, we have to make the HT cap the same */
3740         if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) {
3741                 int max_ampdu;
3742
3743                 max_ampdu = (ssid->vht_capa &
3744                              VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >>
3745                         VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT;
3746
3747                 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3748                 wpa_set_ampdu_factor(wpa_s,
3749                                      (void *) params->htcaps,
3750                                      (void *) params->htcaps_mask,
3751                                      max_ampdu);
3752         }
3753 #endif /* CONFIG_HT_OVERRIDES */
3754
3755 #define OVERRIDE_MCS(i)                                                 \
3756         if (ssid->vht_tx_mcs_nss_ ##i >= 0) {                           \
3757                 vhtcaps_mask->vht_supported_mcs_set.tx_map |=           \
3758                         3 << 2 * (i - 1);                               \
3759                 vhtcaps->vht_supported_mcs_set.tx_map |=                \
3760                         ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1);       \
3761         }                                                               \
3762         if (ssid->vht_rx_mcs_nss_ ##i >= 0) {                           \
3763                 vhtcaps_mask->vht_supported_mcs_set.rx_map |=           \
3764                         3 << 2 * (i - 1);                               \
3765                 vhtcaps->vht_supported_mcs_set.rx_map |=                \
3766                         ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1);       \
3767         }
3768
3769         OVERRIDE_MCS(1);
3770         OVERRIDE_MCS(2);
3771         OVERRIDE_MCS(3);
3772         OVERRIDE_MCS(4);
3773         OVERRIDE_MCS(5);
3774         OVERRIDE_MCS(6);
3775         OVERRIDE_MCS(7);
3776         OVERRIDE_MCS(8);
3777 }
3778 #endif /* CONFIG_VHT_OVERRIDES */
3779
3780
3781 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3782 {
3783 #ifdef PCSC_FUNCS
3784         size_t len;
3785
3786         if (!wpa_s->conf->pcsc_reader)
3787                 return 0;
3788
3789         wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3790         if (!wpa_s->scard)
3791                 return 1;
3792
3793         if (wpa_s->conf->pcsc_pin &&
3794             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3795                 scard_deinit(wpa_s->scard);
3796                 wpa_s->scard = NULL;
3797                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3798                 return -1;
3799         }
3800
3801         len = sizeof(wpa_s->imsi) - 1;
3802         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3803                 scard_deinit(wpa_s->scard);
3804                 wpa_s->scard = NULL;
3805                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3806                 return -1;
3807         }
3808         wpa_s->imsi[len] = '\0';
3809
3810         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3811
3812         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3813                    wpa_s->imsi, wpa_s->mnc_len);
3814
3815         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3816         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3817 #endif /* PCSC_FUNCS */
3818
3819         return 0;
3820 }
3821
3822
3823 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3824 {
3825         char *val, *pos;
3826
3827         ext_password_deinit(wpa_s->ext_pw);
3828         wpa_s->ext_pw = NULL;
3829         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3830
3831         if (!wpa_s->conf->ext_password_backend)
3832                 return 0;
3833
3834         val = os_strdup(wpa_s->conf->ext_password_backend);
3835         if (val == NULL)
3836                 return -1;
3837         pos = os_strchr(val, ':');
3838         if (pos)
3839                 *pos++ = '\0';
3840
3841         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
3842
3843         wpa_s->ext_pw = ext_password_init(val, pos);
3844         os_free(val);
3845         if (wpa_s->ext_pw == NULL) {
3846                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
3847                 return -1;
3848         }
3849         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3850
3851         return 0;
3852 }
3853
3854
3855 #ifdef CONFIG_FST
3856
3857 static const u8 * wpas_fst_get_bssid_cb(void *ctx)
3858 {
3859         struct wpa_supplicant *wpa_s = ctx;
3860
3861         return (is_zero_ether_addr(wpa_s->bssid) ||
3862                 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
3863 }
3864
3865
3866 static void wpas_fst_get_channel_info_cb(void *ctx,
3867                                          enum hostapd_hw_mode *hw_mode,
3868                                          u8 *channel)
3869 {
3870         struct wpa_supplicant *wpa_s = ctx;
3871
3872         if (wpa_s->current_bss) {
3873                 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
3874                                                   channel);
3875         } else if (wpa_s->hw.num_modes) {
3876                 *hw_mode = wpa_s->hw.modes[0].mode;
3877         } else {
3878                 WPA_ASSERT(0);
3879                 *hw_mode = 0;
3880         }
3881 }
3882
3883
3884 static int wpas_fst_get_hw_modes(void *ctx, struct hostapd_hw_modes **modes)
3885 {
3886         struct wpa_supplicant *wpa_s = ctx;
3887
3888         *modes = wpa_s->hw.modes;
3889         return wpa_s->hw.num_modes;
3890 }
3891
3892
3893 static void wpas_fst_set_ies_cb(void *ctx, const struct wpabuf *fst_ies)
3894 {
3895         struct wpa_supplicant *wpa_s = ctx;
3896
3897         wpa_hexdump_buf(MSG_DEBUG, "FST: Set IEs", fst_ies);
3898         wpa_s->fst_ies = fst_ies;
3899 }
3900
3901
3902 static int wpas_fst_send_action_cb(void *ctx, const u8 *da, struct wpabuf *data)
3903 {
3904         struct wpa_supplicant *wpa_s = ctx;
3905
3906         WPA_ASSERT(os_memcmp(wpa_s->bssid, da, ETH_ALEN) == 0);
3907         return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
3908                                           wpa_s->own_addr, wpa_s->bssid,
3909                                           wpabuf_head(data), wpabuf_len(data),
3910                                    0);
3911 }
3912
3913
3914 static const struct wpabuf * wpas_fst_get_mb_ie_cb(void *ctx, const u8 *addr)
3915 {
3916         struct wpa_supplicant *wpa_s = ctx;
3917
3918         WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
3919         return wpa_s->received_mb_ies;
3920 }
3921
3922
3923 static void wpas_fst_update_mb_ie_cb(void *ctx, const u8 *addr,
3924                                      const u8 *buf, size_t size)
3925 {
3926         struct wpa_supplicant *wpa_s = ctx;
3927         struct mb_ies_info info;
3928
3929         WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
3930
3931         if (!mb_ies_info_by_ies(&info, buf, size)) {
3932                 wpabuf_free(wpa_s->received_mb_ies);
3933                 wpa_s->received_mb_ies = mb_ies_by_info(&info);
3934         }
3935 }
3936
3937
3938 const u8 * wpas_fst_get_peer_first(void *ctx, struct fst_get_peer_ctx **get_ctx,
3939                                    Boolean mb_only)
3940 {
3941         struct wpa_supplicant *wpa_s = ctx;
3942
3943         *get_ctx = NULL;
3944         if (!is_zero_ether_addr(wpa_s->bssid))
3945                 return (wpa_s->received_mb_ies || !mb_only) ?
3946                         wpa_s->bssid : NULL;
3947         return NULL;
3948 }
3949
3950
3951 const u8 * wpas_fst_get_peer_next(void *ctx, struct fst_get_peer_ctx **get_ctx,
3952                                   Boolean mb_only)
3953 {
3954         return NULL;
3955 }
3956
3957 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
3958                                        struct fst_wpa_obj *iface_obj)
3959 {
3960         iface_obj->ctx              = wpa_s;
3961         iface_obj->get_bssid        = wpas_fst_get_bssid_cb;
3962         iface_obj->get_channel_info = wpas_fst_get_channel_info_cb;
3963         iface_obj->get_hw_modes     = wpas_fst_get_hw_modes;
3964         iface_obj->set_ies          = wpas_fst_set_ies_cb;
3965         iface_obj->send_action      = wpas_fst_send_action_cb;
3966         iface_obj->get_mb_ie        = wpas_fst_get_mb_ie_cb;
3967         iface_obj->update_mb_ie     = wpas_fst_update_mb_ie_cb;
3968         iface_obj->get_peer_first   = wpas_fst_get_peer_first;
3969         iface_obj->get_peer_next    = wpas_fst_get_peer_next;
3970 }
3971 #endif /* CONFIG_FST */
3972
3973 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
3974                                     const struct wpa_driver_capa *capa)
3975 {
3976         struct wowlan_triggers *triggers;
3977         int ret = 0;
3978
3979         if (!wpa_s->conf->wowlan_triggers)
3980                 return 0;
3981
3982         triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
3983         if (triggers) {
3984                 ret = wpa_drv_wowlan(wpa_s, triggers);
3985                 os_free(triggers);
3986         }
3987         return ret;
3988 }
3989
3990
3991 static enum wpa_radio_work_band wpas_freq_to_band(int freq)
3992 {
3993         if (freq < 3000)
3994                 return BAND_2_4_GHZ;
3995         if (freq > 50000)
3996                 return BAND_60_GHZ;
3997         return BAND_5_GHZ;
3998 }
3999
4000
4001 static unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s,
4002                                    const int *freqs)
4003 {
4004         int i;
4005         unsigned int band = 0;
4006
4007         if (freqs) {
4008                 /* freqs are specified for the radio work */
4009                 for (i = 0; freqs[i]; i++)
4010                         band |= wpas_freq_to_band(freqs[i]);
4011         } else {
4012                 /*
4013                  * freqs are not specified, implies all
4014                  * the supported freqs by HW
4015                  */
4016                 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4017                         if (wpa_s->hw.modes[i].num_channels != 0) {
4018                                 if (wpa_s->hw.modes[i].mode ==
4019                                     HOSTAPD_MODE_IEEE80211B ||
4020                                     wpa_s->hw.modes[i].mode ==
4021                                     HOSTAPD_MODE_IEEE80211G)
4022                                         band |= BAND_2_4_GHZ;
4023                                 else if (wpa_s->hw.modes[i].mode ==
4024                                          HOSTAPD_MODE_IEEE80211A)
4025                                         band |= BAND_5_GHZ;
4026                                 else if (wpa_s->hw.modes[i].mode ==
4027                                          HOSTAPD_MODE_IEEE80211AD)
4028                                         band |= BAND_60_GHZ;
4029                                 else if (wpa_s->hw.modes[i].mode ==
4030                                          HOSTAPD_MODE_IEEE80211ANY)
4031                                         band = BAND_2_4_GHZ | BAND_5_GHZ |
4032                                                 BAND_60_GHZ;
4033                         }
4034                 }
4035         }
4036
4037         return band;
4038 }
4039
4040
4041 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
4042                                               const char *rn)
4043 {
4044         struct wpa_supplicant *iface = wpa_s->global->ifaces;
4045         struct wpa_radio *radio;
4046
4047         while (rn && iface) {
4048                 radio = iface->radio;
4049                 if (radio && os_strcmp(rn, radio->name) == 0) {
4050                         wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
4051                                    wpa_s->ifname, rn);
4052                         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4053                         return radio;
4054                 }
4055
4056                 iface = iface->next;
4057         }
4058
4059         wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
4060                    wpa_s->ifname, rn ? rn : "N/A");
4061         radio = os_zalloc(sizeof(*radio));
4062         if (radio == NULL)
4063                 return NULL;
4064
4065         if (rn)
4066                 os_strlcpy(radio->name, rn, sizeof(radio->name));
4067         dl_list_init(&radio->ifaces);
4068         dl_list_init(&radio->work);
4069         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4070
4071         return radio;
4072 }
4073
4074
4075 static void radio_work_free(struct wpa_radio_work *work)
4076 {
4077         if (work->wpa_s->scan_work == work) {
4078                 /* This should not really happen. */
4079                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4080                         work->type, work, work->started);
4081                 work->wpa_s->scan_work = NULL;
4082         }
4083
4084 #ifdef CONFIG_P2P
4085         if (work->wpa_s->p2p_scan_work == work) {
4086                 /* This should not really happen. */
4087                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4088                         work->type, work, work->started);
4089                 work->wpa_s->p2p_scan_work = NULL;
4090         }
4091 #endif /* CONFIG_P2P */
4092
4093         if (work->started) {
4094                 work->wpa_s->radio->num_active_works--;
4095                 wpa_dbg(work->wpa_s, MSG_DEBUG,
4096                         "radio_work_free('%s'@%p: num_active_works --> %u",
4097                         work->type, work,
4098                         work->wpa_s->radio->num_active_works);
4099         }
4100
4101         dl_list_del(&work->list);
4102         os_free(work);
4103 }
4104
4105
4106 static struct wpa_radio_work * radio_work_get_next_work(struct wpa_radio *radio)
4107 {
4108         struct wpa_radio_work *active_work = NULL;
4109         struct wpa_radio_work *tmp;
4110
4111         /* Get the active work to know the type and band. */
4112         dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4113                 if (tmp->started) {
4114                         active_work = tmp;
4115                         break;
4116                 }
4117         }
4118
4119         if (!active_work) {
4120                 /* No active work, start one */
4121                 radio->num_active_works = 0;
4122                 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work,
4123                                  list) {
4124                         if (os_strcmp(tmp->type, "scan") == 0 &&
4125                             radio->external_scan_running &&
4126                             (((struct wpa_driver_scan_params *)
4127                               tmp->ctx)->only_new_results ||
4128                              tmp->wpa_s->clear_driver_scan_cache))
4129                                 continue;
4130                         return tmp;
4131                 }
4132                 return NULL;
4133         }
4134
4135         if (os_strcmp(active_work->type, "sme-connect") == 0 ||
4136             os_strcmp(active_work->type, "connect") == 0) {
4137                 /*
4138                  * If the active work is either connect or sme-connect,
4139                  * do not parallelize them with other radio works.
4140                  */
4141                 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4142                         "Do not parallelize radio work with %s",
4143                         active_work->type);
4144                 return NULL;
4145         }
4146
4147         dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4148                 if (tmp->started)
4149                         continue;
4150
4151                 /*
4152                  * If connect or sme-connect are enqueued, parallelize only
4153                  * those operations ahead of them in the queue.
4154                  */
4155                 if (os_strcmp(tmp->type, "connect") == 0 ||
4156                     os_strcmp(tmp->type, "sme-connect") == 0)
4157                         break;
4158
4159                 /*
4160                  * Check that the radio works are distinct and
4161                  * on different bands.
4162                  */
4163                 if (os_strcmp(active_work->type, tmp->type) != 0 &&
4164                     (active_work->bands != tmp->bands)) {
4165                         /*
4166                          * If a scan has to be scheduled through nl80211 scan
4167                          * interface and if an external scan is already running,
4168                          * do not schedule the scan since it is likely to get
4169                          * rejected by kernel.
4170                          */
4171                         if (os_strcmp(tmp->type, "scan") == 0 &&
4172                             radio->external_scan_running &&
4173                             (((struct wpa_driver_scan_params *)
4174                               tmp->ctx)->only_new_results ||
4175                              tmp->wpa_s->clear_driver_scan_cache))
4176                                 continue;
4177
4178                         wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4179                                 "active_work:%s new_work:%s",
4180                                 active_work->type, tmp->type);
4181                         return tmp;
4182                 }
4183         }
4184
4185         /* Did not find a radio work to schedule in parallel. */
4186         return NULL;
4187 }
4188
4189
4190 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
4191 {
4192         struct wpa_radio *radio = eloop_ctx;
4193         struct wpa_radio_work *work;
4194         struct os_reltime now, diff;
4195         struct wpa_supplicant *wpa_s;
4196
4197         work = dl_list_first(&radio->work, struct wpa_radio_work, list);
4198         if (work == NULL) {
4199                 radio->num_active_works = 0;
4200                 return;
4201         }
4202
4203         wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
4204                               radio_list);
4205
4206         if (!(wpa_s &&
4207               wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
4208                 if (work->started)
4209                         return; /* already started and still in progress */
4210
4211                 if (wpa_s && wpa_s->radio->external_scan_running) {
4212                         wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
4213                         return;
4214                 }
4215         } else {
4216                 work = NULL;
4217                 if (radio->num_active_works < MAX_ACTIVE_WORKS) {
4218                         /* get the work to schedule next */
4219                         work = radio_work_get_next_work(radio);
4220                 }
4221                 if (!work)
4222                         return;
4223         }
4224
4225         wpa_s = work->wpa_s;
4226         os_get_reltime(&now);
4227         os_reltime_sub(&now, &work->time, &diff);
4228         wpa_dbg(wpa_s, MSG_DEBUG,
4229                 "Starting radio work '%s'@%p after %ld.%06ld second wait",
4230                 work->type, work, diff.sec, diff.usec);
4231         work->started = 1;
4232         work->time = now;
4233         radio->num_active_works++;
4234
4235         work->cb(work, 0);
4236
4237         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
4238             radio->num_active_works < MAX_ACTIVE_WORKS)
4239                 radio_work_check_next(wpa_s);
4240 }
4241
4242
4243 /*
4244  * This function removes both started and pending radio works running on
4245  * the provided interface's radio.
4246  * Prior to the removal of the radio work, its callback (cb) is called with
4247  * deinit set to be 1. Each work's callback is responsible for clearing its
4248  * internal data and restoring to a correct state.
4249  * @wpa_s: wpa_supplicant data
4250  * @type: type of works to be removed
4251  * @remove_all: 1 to remove all the works on this radio, 0 to remove only
4252  * this interface's works.
4253  */
4254 void radio_remove_works(struct wpa_supplicant *wpa_s,
4255                         const char *type, int remove_all)
4256 {
4257         struct wpa_radio_work *work, *tmp;
4258         struct wpa_radio *radio = wpa_s->radio;
4259
4260         dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
4261                               list) {
4262                 if (type && os_strcmp(type, work->type) != 0)
4263                         continue;
4264
4265                 /* skip other ifaces' works */
4266                 if (!remove_all && work->wpa_s != wpa_s)
4267                         continue;
4268
4269                 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
4270                         work->type, work, work->started ? " (started)" : "");
4271                 work->cb(work, 1);
4272                 radio_work_free(work);
4273         }
4274
4275         /* in case we removed the started work */
4276         radio_work_check_next(wpa_s);
4277 }
4278
4279
4280 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
4281 {
4282         struct wpa_radio *radio = wpa_s->radio;
4283
4284         if (!radio)
4285                 return;
4286
4287         wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
4288                    wpa_s->ifname, radio->name);
4289         dl_list_del(&wpa_s->radio_list);
4290         radio_remove_works(wpa_s, NULL, 0);
4291         wpa_s->radio = NULL;
4292         if (!dl_list_empty(&radio->ifaces))
4293                 return; /* Interfaces remain for this radio */
4294
4295         wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
4296         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4297         os_free(radio);
4298 }
4299
4300
4301 void radio_work_check_next(struct wpa_supplicant *wpa_s)
4302 {
4303         struct wpa_radio *radio = wpa_s->radio;
4304
4305         if (dl_list_empty(&radio->work))
4306                 return;
4307         if (wpa_s->ext_work_in_progress) {
4308                 wpa_printf(MSG_DEBUG,
4309                            "External radio work in progress - delay start of pending item");
4310                 return;
4311         }
4312         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4313         eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
4314 }
4315
4316
4317 /**
4318  * radio_add_work - Add a radio work item
4319  * @wpa_s: Pointer to wpa_supplicant data
4320  * @freq: Frequency of the offchannel operation in MHz or 0
4321  * @type: Unique identifier for each type of work
4322  * @next: Force as the next work to be executed
4323  * @cb: Callback function for indicating when radio is available
4324  * @ctx: Context pointer for the work (work->ctx in cb())
4325  * Returns: 0 on success, -1 on failure
4326  *
4327  * This function is used to request time for an operation that requires
4328  * exclusive radio control. Once the radio is available, the registered callback
4329  * function will be called. radio_work_done() must be called once the exclusive
4330  * radio operation has been completed, so that the radio is freed for other
4331  * operations. The special case of deinit=1 is used to free the context data
4332  * during interface removal. That does not allow the callback function to start
4333  * the radio operation, i.e., it must free any resources allocated for the radio
4334  * work and return.
4335  *
4336  * The @freq parameter can be used to indicate a single channel on which the
4337  * offchannel operation will occur. This may allow multiple radio work
4338  * operations to be performed in parallel if they apply for the same channel.
4339  * Setting this to 0 indicates that the work item may use multiple channels or
4340  * requires exclusive control of the radio.
4341  */
4342 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
4343                    const char *type, int next,
4344                    void (*cb)(struct wpa_radio_work *work, int deinit),
4345                    void *ctx)
4346 {
4347         struct wpa_radio *radio = wpa_s->radio;
4348         struct wpa_radio_work *work;
4349         int was_empty;
4350
4351         work = os_zalloc(sizeof(*work));
4352         if (work == NULL)
4353                 return -1;
4354         wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
4355         os_get_reltime(&work->time);
4356         work->freq = freq;
4357         work->type = type;
4358         work->wpa_s = wpa_s;
4359         work->cb = cb;
4360         work->ctx = ctx;
4361
4362         if (freq)
4363                 work->bands = wpas_freq_to_band(freq);
4364         else if (os_strcmp(type, "scan") == 0 ||
4365                  os_strcmp(type, "p2p-scan") == 0)
4366                 work->bands = wpas_get_bands(wpa_s,
4367                                              ((struct wpa_driver_scan_params *)
4368                                               ctx)->freqs);
4369         else
4370                 work->bands = wpas_get_bands(wpa_s, NULL);
4371
4372         was_empty = dl_list_empty(&wpa_s->radio->work);
4373         if (next)
4374                 dl_list_add(&wpa_s->radio->work, &work->list);
4375         else
4376                 dl_list_add_tail(&wpa_s->radio->work, &work->list);
4377         if (was_empty) {
4378                 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
4379                 radio_work_check_next(wpa_s);
4380         } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
4381                    && radio->num_active_works < MAX_ACTIVE_WORKS) {
4382                 wpa_dbg(wpa_s, MSG_DEBUG,
4383                         "Try to schedule a radio work (num_active_works=%u)",
4384                         radio->num_active_works);
4385                 radio_work_check_next(wpa_s);
4386         }
4387
4388         return 0;
4389 }
4390
4391
4392 /**
4393  * radio_work_done - Indicate that a radio work item has been completed
4394  * @work: Completed work
4395  *
4396  * This function is called once the callback function registered with
4397  * radio_add_work() has completed its work.
4398  */
4399 void radio_work_done(struct wpa_radio_work *work)
4400 {
4401         struct wpa_supplicant *wpa_s = work->wpa_s;
4402         struct os_reltime now, diff;
4403         unsigned int started = work->started;
4404
4405         os_get_reltime(&now);
4406         os_reltime_sub(&now, &work->time, &diff);
4407         wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
4408                 work->type, work, started ? "done" : "canceled",
4409                 diff.sec, diff.usec);
4410         radio_work_free(work);
4411         if (started)
4412                 radio_work_check_next(wpa_s);
4413 }
4414
4415
4416 struct wpa_radio_work *
4417 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
4418 {
4419         struct wpa_radio_work *work;
4420         struct wpa_radio *radio = wpa_s->radio;
4421
4422         dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
4423                 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
4424                         return work;
4425         }
4426
4427         return NULL;
4428 }
4429
4430
4431 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
4432                             struct wpa_interface *iface)
4433 {
4434         const char *ifname, *driver, *rn;
4435
4436         driver = iface->driver;
4437 next_driver:
4438         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
4439                 return -1;
4440
4441         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
4442         if (wpa_s->drv_priv == NULL) {
4443                 const char *pos;
4444                 pos = driver ? os_strchr(driver, ',') : NULL;
4445                 if (pos) {
4446                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
4447                                 "driver interface - try next driver wrapper");
4448                         driver = pos + 1;
4449                         goto next_driver;
4450                 }
4451                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
4452                         "interface");
4453                 return -1;
4454         }
4455         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
4456                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
4457                         "driver_param '%s'", wpa_s->conf->driver_param);
4458                 return -1;
4459         }
4460
4461         ifname = wpa_drv_get_ifname(wpa_s);
4462         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
4463                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
4464                         "interface name with '%s'", ifname);
4465                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
4466         }
4467
4468         rn = wpa_driver_get_radio_name(wpa_s);
4469         if (rn && rn[0] == '\0')
4470                 rn = NULL;
4471
4472         wpa_s->radio = radio_add_interface(wpa_s, rn);
4473         if (wpa_s->radio == NULL)
4474                 return -1;
4475
4476         return 0;
4477 }
4478
4479
4480 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
4481                                      struct wpa_interface *iface)
4482 {
4483         struct wpa_driver_capa capa;
4484         int capa_res;
4485
4486         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
4487                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
4488                    iface->confname ? iface->confname : "N/A",
4489                    iface->driver ? iface->driver : "default",
4490                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
4491                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
4492
4493         if (iface->confname) {
4494 #ifdef CONFIG_BACKEND_FILE
4495                 wpa_s->confname = os_rel2abs_path(iface->confname);
4496                 if (wpa_s->confname == NULL) {
4497                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
4498                                    "for configuration file '%s'.",
4499                                    iface->confname);
4500                         return -1;
4501                 }
4502                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
4503                            iface->confname, wpa_s->confname);
4504 #else /* CONFIG_BACKEND_FILE */
4505                 wpa_s->confname = os_strdup(iface->confname);
4506 #endif /* CONFIG_BACKEND_FILE */
4507                 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
4508                 if (wpa_s->conf == NULL) {
4509                         wpa_printf(MSG_ERROR, "Failed to read or parse "
4510                                    "configuration '%s'.", wpa_s->confname);
4511                         return -1;
4512                 }
4513                 wpa_s->confanother = os_rel2abs_path(iface->confanother);
4514                 wpa_config_read(wpa_s->confanother, wpa_s->conf);
4515
4516                 /*
4517                  * Override ctrl_interface and driver_param if set on command
4518                  * line.
4519                  */
4520                 if (iface->ctrl_interface) {
4521                         os_free(wpa_s->conf->ctrl_interface);
4522                         wpa_s->conf->ctrl_interface =
4523                                 os_strdup(iface->ctrl_interface);
4524                 }
4525
4526                 if (iface->driver_param) {
4527                         os_free(wpa_s->conf->driver_param);
4528                         wpa_s->conf->driver_param =
4529                                 os_strdup(iface->driver_param);
4530                 }
4531
4532                 if (iface->p2p_mgmt && !iface->ctrl_interface) {
4533                         os_free(wpa_s->conf->ctrl_interface);
4534                         wpa_s->conf->ctrl_interface = NULL;
4535                 }
4536         } else
4537                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
4538                                                      iface->driver_param);
4539
4540         if (wpa_s->conf == NULL) {
4541                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
4542                 return -1;
4543         }
4544
4545         if (iface->ifname == NULL) {
4546                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
4547                 return -1;
4548         }
4549         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
4550                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
4551                            iface->ifname);
4552                 return -1;
4553         }
4554         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
4555
4556         if (iface->bridge_ifname) {
4557                 if (os_strlen(iface->bridge_ifname) >=
4558                     sizeof(wpa_s->bridge_ifname)) {
4559                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
4560                                    "name '%s'.", iface->bridge_ifname);
4561                         return -1;
4562                 }
4563                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
4564                            sizeof(wpa_s->bridge_ifname));
4565         }
4566
4567         /* RSNA Supplicant Key Management - INITIALIZE */
4568         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
4569         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
4570
4571         /* Initialize driver interface and register driver event handler before
4572          * L2 receive handler so that association events are processed before
4573          * EAPOL-Key packets if both become available for the same select()
4574          * call. */
4575         if (wpas_init_driver(wpa_s, iface) < 0)
4576                 return -1;
4577
4578         if (wpa_supplicant_init_wpa(wpa_s) < 0)
4579                 return -1;
4580
4581         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
4582                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
4583                           NULL);
4584         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
4585
4586         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
4587             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
4588                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
4589                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4590                         "dot11RSNAConfigPMKLifetime");
4591                 return -1;
4592         }
4593
4594         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
4595             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
4596                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
4597                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4598                         "dot11RSNAConfigPMKReauthThreshold");
4599                 return -1;
4600         }
4601
4602         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
4603             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
4604                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
4605                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4606                         "dot11RSNAConfigSATimeout");
4607                 return -1;
4608         }
4609
4610         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
4611                                                       &wpa_s->hw.num_modes,
4612                                                       &wpa_s->hw.flags);
4613         if (wpa_s->hw.modes) {
4614                 u16 i;
4615
4616                 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4617                         if (wpa_s->hw.modes[i].vht_capab) {
4618                                 wpa_s->hw_capab = CAPAB_VHT;
4619                                 break;
4620                         }
4621
4622                         if (wpa_s->hw.modes[i].ht_capab &
4623                             HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)
4624                                 wpa_s->hw_capab = CAPAB_HT40;
4625                         else if (wpa_s->hw.modes[i].ht_capab &&
4626                                  wpa_s->hw_capab == CAPAB_NO_HT_VHT)
4627                                 wpa_s->hw_capab = CAPAB_HT;
4628                 }
4629         }
4630
4631         capa_res = wpa_drv_get_capa(wpa_s, &capa);
4632         if (capa_res == 0) {
4633                 wpa_s->drv_capa_known = 1;
4634                 wpa_s->drv_flags = capa.flags;
4635                 wpa_s->drv_enc = capa.enc;
4636                 wpa_s->drv_smps_modes = capa.smps_modes;
4637                 wpa_s->drv_rrm_flags = capa.rrm_flags;
4638                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
4639                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
4640                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
4641                 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
4642                 wpa_s->max_sched_scan_plan_interval =
4643                         capa.max_sched_scan_plan_interval;
4644                 wpa_s->max_sched_scan_plan_iterations =
4645                         capa.max_sched_scan_plan_iterations;
4646                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
4647                 wpa_s->max_match_sets = capa.max_match_sets;
4648                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
4649                 wpa_s->max_stations = capa.max_stations;
4650                 wpa_s->extended_capa = capa.extended_capa;
4651                 wpa_s->extended_capa_mask = capa.extended_capa_mask;
4652                 wpa_s->extended_capa_len = capa.extended_capa_len;
4653                 wpa_s->num_multichan_concurrent =
4654                         capa.num_multichan_concurrent;
4655                 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
4656
4657                 if (capa.mac_addr_rand_scan_supported)
4658                         wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
4659                 if (wpa_s->sched_scan_supported &&
4660                     capa.mac_addr_rand_sched_scan_supported)
4661                         wpa_s->mac_addr_rand_supported |=
4662                                 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO);
4663         }
4664         if (wpa_s->max_remain_on_chan == 0)
4665                 wpa_s->max_remain_on_chan = 1000;
4666
4667         /*
4668          * Only take p2p_mgmt parameters when P2P Device is supported.
4669          * Doing it here as it determines whether l2_packet_init() will be done
4670          * during wpa_supplicant_driver_init().
4671          */
4672         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
4673                 wpa_s->p2p_mgmt = iface->p2p_mgmt;
4674         else
4675                 iface->p2p_mgmt = 1;
4676
4677         if (wpa_s->num_multichan_concurrent == 0)
4678                 wpa_s->num_multichan_concurrent = 1;
4679
4680         if (wpa_supplicant_driver_init(wpa_s) < 0)
4681                 return -1;
4682
4683 #ifdef CONFIG_TDLS
4684         if ((!iface->p2p_mgmt ||
4685              !(wpa_s->drv_flags &
4686                WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
4687             wpa_tdls_init(wpa_s->wpa))
4688                 return -1;
4689 #endif /* CONFIG_TDLS */
4690
4691         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
4692             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
4693                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
4694                 return -1;
4695         }
4696
4697 #ifdef CONFIG_FST
4698         if (wpa_s->conf->fst_group_id) {
4699                 struct fst_iface_cfg cfg;
4700                 struct fst_wpa_obj iface_obj;
4701
4702                 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
4703                 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
4704                            sizeof(cfg.group_id));
4705                 cfg.priority = wpa_s->conf->fst_priority;
4706                 cfg.llt = wpa_s->conf->fst_llt;
4707
4708                 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
4709                                         &iface_obj, &cfg);
4710                 if (!wpa_s->fst) {
4711                         wpa_msg(wpa_s, MSG_ERROR,
4712                                 "FST: Cannot attach iface %s to group %s",
4713                                 wpa_s->ifname, cfg.group_id);
4714                         return -1;
4715                 }
4716         }
4717 #endif /* CONFIG_FST */
4718
4719         if (wpas_wps_init(wpa_s))
4720                 return -1;
4721
4722         if (wpa_supplicant_init_eapol(wpa_s) < 0)
4723                 return -1;
4724         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
4725
4726         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
4727         if (wpa_s->ctrl_iface == NULL) {
4728                 wpa_printf(MSG_ERROR,
4729                            "Failed to initialize control interface '%s'.\n"
4730                            "You may have another wpa_supplicant process "
4731                            "already running or the file was\n"
4732                            "left by an unclean termination of wpa_supplicant "
4733                            "in which case you will need\n"
4734                            "to manually remove this file before starting "
4735                            "wpa_supplicant again.\n",
4736                            wpa_s->conf->ctrl_interface);
4737                 return -1;
4738         }
4739
4740         wpa_s->gas = gas_query_init(wpa_s);
4741         if (wpa_s->gas == NULL) {
4742                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
4743                 return -1;
4744         }
4745
4746         if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
4747                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
4748                 return -1;
4749         }
4750
4751         if (wpa_bss_init(wpa_s) < 0)
4752                 return -1;
4753
4754         /*
4755          * Set Wake-on-WLAN triggers, if configured.
4756          * Note: We don't restore/remove the triggers on shutdown (it doesn't
4757          * have effect anyway when the interface is down).
4758          */
4759         if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
4760                 return -1;
4761
4762 #ifdef CONFIG_EAP_PROXY
4763 {
4764         size_t len;
4765         wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
4766                                                      &len);
4767         if (wpa_s->mnc_len > 0) {
4768                 wpa_s->imsi[len] = '\0';
4769                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
4770                            wpa_s->imsi, wpa_s->mnc_len);
4771         } else {
4772                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
4773         }
4774 }
4775 #endif /* CONFIG_EAP_PROXY */
4776
4777         if (pcsc_reader_init(wpa_s) < 0)
4778                 return -1;
4779
4780         if (wpas_init_ext_pw(wpa_s) < 0)
4781                 return -1;
4782
4783         wpas_rrm_reset(wpa_s);
4784
4785         wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
4786
4787 #ifdef CONFIG_HS20
4788         hs20_init(wpa_s);
4789 #endif /* CONFIG_HS20 */
4790 #ifdef CONFIG_MBO
4791         wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
4792 #endif /* CONFIG_MBO */
4793
4794         return 0;
4795 }
4796
4797
4798 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
4799                                         int notify, int terminate)
4800 {
4801         struct wpa_global *global = wpa_s->global;
4802         struct wpa_supplicant *iface, *prev;
4803
4804         if (wpa_s == wpa_s->parent)
4805                 wpas_p2p_group_remove(wpa_s, "*");
4806
4807         iface = global->ifaces;
4808         while (iface) {
4809                 if (iface == wpa_s || iface->parent != wpa_s) {
4810                         iface = iface->next;
4811                         continue;
4812                 }
4813                 wpa_printf(MSG_DEBUG,
4814                            "Remove remaining child interface %s from parent %s",
4815                            iface->ifname, wpa_s->ifname);
4816                 prev = iface;
4817                 iface = iface->next;
4818                 wpa_supplicant_remove_iface(global, prev, terminate);
4819         }
4820
4821         wpa_s->disconnected = 1;
4822         if (wpa_s->drv_priv) {
4823                 wpa_supplicant_deauthenticate(wpa_s,
4824                                               WLAN_REASON_DEAUTH_LEAVING);
4825
4826                 wpa_drv_set_countermeasures(wpa_s, 0);
4827                 wpa_clear_keys(wpa_s, NULL);
4828         }
4829
4830         wpa_supplicant_cleanup(wpa_s);
4831         wpas_p2p_deinit_iface(wpa_s);
4832
4833         wpas_ctrl_radio_work_flush(wpa_s);
4834         radio_remove_interface(wpa_s);
4835
4836 #ifdef CONFIG_FST
4837         if (wpa_s->fst) {
4838                 fst_detach(wpa_s->fst);
4839                 wpa_s->fst = NULL;
4840         }
4841         if (wpa_s->received_mb_ies) {
4842                 wpabuf_free(wpa_s->received_mb_ies);
4843                 wpa_s->received_mb_ies = NULL;
4844         }
4845 #endif /* CONFIG_FST */
4846
4847         if (wpa_s->drv_priv)
4848                 wpa_drv_deinit(wpa_s);
4849
4850         if (notify)
4851                 wpas_notify_iface_removed(wpa_s);
4852
4853         if (terminate)
4854                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
4855
4856         if (wpa_s->ctrl_iface) {
4857                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
4858                 wpa_s->ctrl_iface = NULL;
4859         }
4860
4861 #ifdef CONFIG_MESH
4862         if (wpa_s->ifmsh) {
4863                 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
4864                 wpa_s->ifmsh = NULL;
4865         }
4866 #endif /* CONFIG_MESH */
4867
4868         if (wpa_s->conf != NULL) {
4869                 wpa_config_free(wpa_s->conf);
4870                 wpa_s->conf = NULL;
4871         }
4872
4873         os_free(wpa_s->ssids_from_scan_req);
4874
4875         os_free(wpa_s);
4876 }
4877
4878
4879 /**
4880  * wpa_supplicant_add_iface - Add a new network interface
4881  * @global: Pointer to global data from wpa_supplicant_init()
4882  * @iface: Interface configuration options
4883  * @parent: Parent interface or %NULL to assign new interface as parent
4884  * Returns: Pointer to the created interface or %NULL on failure
4885  *
4886  * This function is used to add new network interfaces for %wpa_supplicant.
4887  * This can be called before wpa_supplicant_run() to add interfaces before the
4888  * main event loop has been started. In addition, new interfaces can be added
4889  * dynamically while %wpa_supplicant is already running. This could happen,
4890  * e.g., when a hotplug network adapter is inserted.
4891  */
4892 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
4893                                                  struct wpa_interface *iface,
4894                                                  struct wpa_supplicant *parent)
4895 {
4896         struct wpa_supplicant *wpa_s;
4897         struct wpa_interface t_iface;
4898         struct wpa_ssid *ssid;
4899
4900         if (global == NULL || iface == NULL)
4901                 return NULL;
4902
4903         wpa_s = wpa_supplicant_alloc(parent);
4904         if (wpa_s == NULL)
4905                 return NULL;
4906
4907         wpa_s->global = global;
4908
4909         t_iface = *iface;
4910         if (global->params.override_driver) {
4911                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
4912                            "('%s' -> '%s')",
4913                            iface->driver, global->params.override_driver);
4914                 t_iface.driver = global->params.override_driver;
4915         }
4916         if (global->params.override_ctrl_interface) {
4917                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
4918                            "ctrl_interface ('%s' -> '%s')",
4919                            iface->ctrl_interface,
4920                            global->params.override_ctrl_interface);
4921                 t_iface.ctrl_interface =
4922                         global->params.override_ctrl_interface;
4923         }
4924         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
4925                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
4926                            iface->ifname);
4927                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
4928                 return NULL;
4929         }
4930
4931         if (iface->p2p_mgmt == 0) {
4932                 /* Notify the control interfaces about new iface */
4933                 if (wpas_notify_iface_added(wpa_s)) {
4934                         wpa_supplicant_deinit_iface(wpa_s, 1, 0);
4935                         return NULL;
4936                 }
4937
4938                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
4939                         wpas_notify_network_added(wpa_s, ssid);
4940         }
4941
4942         wpa_s->next = global->ifaces;
4943         global->ifaces = wpa_s;
4944
4945         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
4946         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
4947
4948 #ifdef CONFIG_P2P
4949         if (wpa_s->global->p2p == NULL &&
4950             !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
4951             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
4952             wpas_p2p_add_p2pdev_interface(
4953                     wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
4954                 wpa_printf(MSG_INFO,
4955                            "P2P: Failed to enable P2P Device interface");
4956                 /* Try to continue without. P2P will be disabled. */
4957         }
4958 #endif /* CONFIG_P2P */
4959
4960         return wpa_s;
4961 }
4962
4963
4964 /**
4965  * wpa_supplicant_remove_iface - Remove a network interface
4966  * @global: Pointer to global data from wpa_supplicant_init()
4967  * @wpa_s: Pointer to the network interface to be removed
4968  * Returns: 0 if interface was removed, -1 if interface was not found
4969  *
4970  * This function can be used to dynamically remove network interfaces from
4971  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
4972  * addition, this function is used to remove all remaining interfaces when
4973  * %wpa_supplicant is terminated.
4974  */
4975 int wpa_supplicant_remove_iface(struct wpa_global *global,
4976                                 struct wpa_supplicant *wpa_s,
4977                                 int terminate)
4978 {
4979         struct wpa_supplicant *prev;
4980 #ifdef CONFIG_MESH
4981         unsigned int mesh_if_created = wpa_s->mesh_if_created;
4982         char *ifname = NULL;
4983 #endif /* CONFIG_MESH */
4984
4985         /* Remove interface from the global list of interfaces */
4986         prev = global->ifaces;
4987         if (prev == wpa_s) {
4988                 global->ifaces = wpa_s->next;
4989         } else {
4990                 while (prev && prev->next != wpa_s)
4991                         prev = prev->next;
4992                 if (prev == NULL)
4993                         return -1;
4994                 prev->next = wpa_s->next;
4995         }
4996
4997         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
4998
4999 #ifdef CONFIG_MESH
5000         if (mesh_if_created) {
5001                 ifname = os_strdup(wpa_s->ifname);
5002                 if (ifname == NULL) {
5003                         wpa_dbg(wpa_s, MSG_ERROR,
5004                                 "mesh: Failed to malloc ifname");
5005                         return -1;
5006                 }
5007         }
5008 #endif /* CONFIG_MESH */
5009
5010         if (global->p2p_group_formation == wpa_s)
5011                 global->p2p_group_formation = NULL;
5012         if (global->p2p_invite_group == wpa_s)
5013                 global->p2p_invite_group = NULL;
5014         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
5015
5016 #ifdef CONFIG_MESH
5017         if (mesh_if_created) {
5018                 wpa_drv_if_remove(global->ifaces, WPA_IF_MESH, ifname);
5019                 os_free(ifname);
5020         }
5021 #endif /* CONFIG_MESH */
5022
5023         return 0;
5024 }
5025
5026
5027 /**
5028  * wpa_supplicant_get_eap_mode - Get the current EAP mode
5029  * @wpa_s: Pointer to the network interface
5030  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
5031  */
5032 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
5033 {
5034         const char *eapol_method;
5035
5036         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
5037             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
5038                 return "NO-EAP";
5039         }
5040
5041         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
5042         if (eapol_method == NULL)
5043                 return "UNKNOWN-EAP";
5044
5045         return eapol_method;
5046 }
5047
5048
5049 /**
5050  * wpa_supplicant_get_iface - Get a new network interface
5051  * @global: Pointer to global data from wpa_supplicant_init()
5052  * @ifname: Interface name
5053  * Returns: Pointer to the interface or %NULL if not found
5054  */
5055 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
5056                                                  const char *ifname)
5057 {
5058         struct wpa_supplicant *wpa_s;
5059
5060         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5061                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5062                         return wpa_s;
5063         }
5064         return NULL;
5065 }
5066
5067
5068 #ifndef CONFIG_NO_WPA_MSG
5069 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
5070 {
5071         struct wpa_supplicant *wpa_s = ctx;
5072         if (wpa_s == NULL)
5073                 return NULL;
5074         return wpa_s->ifname;
5075 }
5076 #endif /* CONFIG_NO_WPA_MSG */
5077
5078
5079 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL
5080 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10
5081 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */
5082
5083 /* Periodic cleanup tasks */
5084 static void wpas_periodic(void *eloop_ctx, void *timeout_ctx)
5085 {
5086         struct wpa_global *global = eloop_ctx;
5087         struct wpa_supplicant *wpa_s;
5088
5089         eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5090                                wpas_periodic, global, NULL);
5091
5092 #ifdef CONFIG_P2P
5093         if (global->p2p)
5094                 p2p_expire_peers(global->p2p);
5095 #endif /* CONFIG_P2P */
5096
5097         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5098                 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
5099 #ifdef CONFIG_AP
5100                 ap_periodic(wpa_s);
5101 #endif /* CONFIG_AP */
5102         }
5103 }
5104
5105
5106 /**
5107  * wpa_supplicant_init - Initialize %wpa_supplicant
5108  * @params: Parameters for %wpa_supplicant
5109  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
5110  *
5111  * This function is used to initialize %wpa_supplicant. After successful
5112  * initialization, the returned data pointer can be used to add and remove
5113  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
5114  */
5115 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
5116 {
5117         struct wpa_global *global;
5118         int ret, i;
5119
5120         if (params == NULL)
5121                 return NULL;
5122
5123 #ifdef CONFIG_DRIVER_NDIS
5124         {
5125                 void driver_ndis_init_ops(void);
5126                 driver_ndis_init_ops();
5127         }
5128 #endif /* CONFIG_DRIVER_NDIS */
5129
5130 #ifndef CONFIG_NO_WPA_MSG
5131         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
5132 #endif /* CONFIG_NO_WPA_MSG */
5133
5134         if (params->wpa_debug_file_path)
5135                 wpa_debug_open_file(params->wpa_debug_file_path);
5136         else
5137                 wpa_debug_setup_stdout();
5138         if (params->wpa_debug_syslog)
5139                 wpa_debug_open_syslog();
5140         if (params->wpa_debug_tracing) {
5141                 ret = wpa_debug_open_linux_tracing();
5142                 if (ret) {
5143                         wpa_printf(MSG_ERROR,
5144                                    "Failed to enable trace logging");
5145                         return NULL;
5146                 }
5147         }
5148
5149         ret = eap_register_methods();
5150         if (ret) {
5151                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
5152                 if (ret == -2)
5153                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
5154                                    "the same EAP type.");
5155                 return NULL;
5156         }
5157
5158         global = os_zalloc(sizeof(*global));
5159         if (global == NULL)
5160                 return NULL;
5161         dl_list_init(&global->p2p_srv_bonjour);
5162         dl_list_init(&global->p2p_srv_upnp);
5163         global->params.daemonize = params->daemonize;
5164         global->params.wait_for_monitor = params->wait_for_monitor;
5165         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
5166         if (params->pid_file)
5167                 global->params.pid_file = os_strdup(params->pid_file);
5168         if (params->ctrl_interface)
5169                 global->params.ctrl_interface =
5170                         os_strdup(params->ctrl_interface);
5171         if (params->ctrl_interface_group)
5172                 global->params.ctrl_interface_group =
5173                         os_strdup(params->ctrl_interface_group);
5174         if (params->override_driver)
5175                 global->params.override_driver =
5176                         os_strdup(params->override_driver);
5177         if (params->override_ctrl_interface)
5178                 global->params.override_ctrl_interface =
5179                         os_strdup(params->override_ctrl_interface);
5180 #ifdef CONFIG_P2P
5181         if (params->conf_p2p_dev)
5182                 global->params.conf_p2p_dev =
5183                         os_strdup(params->conf_p2p_dev);
5184 #endif /* CONFIG_P2P */
5185         wpa_debug_level = global->params.wpa_debug_level =
5186                 params->wpa_debug_level;
5187         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
5188                 params->wpa_debug_show_keys;
5189         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
5190                 params->wpa_debug_timestamp;
5191
5192         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
5193
5194         if (eloop_init()) {
5195                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
5196                 wpa_supplicant_deinit(global);
5197                 return NULL;
5198         }
5199
5200         random_init(params->entropy_file);
5201
5202         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
5203         if (global->ctrl_iface == NULL) {
5204                 wpa_supplicant_deinit(global);
5205                 return NULL;
5206         }
5207
5208         if (wpas_notify_supplicant_initialized(global)) {
5209                 wpa_supplicant_deinit(global);
5210                 return NULL;
5211         }
5212
5213         for (i = 0; wpa_drivers[i]; i++)
5214                 global->drv_count++;
5215         if (global->drv_count == 0) {
5216                 wpa_printf(MSG_ERROR, "No drivers enabled");
5217                 wpa_supplicant_deinit(global);
5218                 return NULL;
5219         }
5220         global->drv_priv = os_calloc(global->drv_count, sizeof(void *));
5221         if (global->drv_priv == NULL) {
5222                 wpa_supplicant_deinit(global);
5223                 return NULL;
5224         }
5225
5226 #ifdef CONFIG_WIFI_DISPLAY
5227         if (wifi_display_init(global) < 0) {
5228                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
5229                 wpa_supplicant_deinit(global);
5230                 return NULL;
5231         }
5232 #endif /* CONFIG_WIFI_DISPLAY */
5233
5234         eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5235                                wpas_periodic, global, NULL);
5236
5237         return global;
5238 }
5239
5240
5241 /**
5242  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
5243  * @global: Pointer to global data from wpa_supplicant_init()
5244  * Returns: 0 after successful event loop run, -1 on failure
5245  *
5246  * This function starts the main event loop and continues running as long as
5247  * there are any remaining events. In most cases, this function is running as
5248  * long as the %wpa_supplicant process in still in use.
5249  */
5250 int wpa_supplicant_run(struct wpa_global *global)
5251 {
5252         struct wpa_supplicant *wpa_s;
5253
5254         if (global->params.daemonize &&
5255             (wpa_supplicant_daemon(global->params.pid_file) ||
5256              eloop_sock_requeue()))
5257                 return -1;
5258
5259         if (global->params.wait_for_monitor) {
5260                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
5261                         if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
5262                                 wpa_supplicant_ctrl_iface_wait(
5263                                         wpa_s->ctrl_iface);
5264         }
5265
5266         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
5267         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
5268
5269         eloop_run();
5270
5271         return 0;
5272 }
5273
5274
5275 /**
5276  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
5277  * @global: Pointer to global data from wpa_supplicant_init()
5278  *
5279  * This function is called to deinitialize %wpa_supplicant and to free all
5280  * allocated resources. Remaining network interfaces will also be removed.
5281  */
5282 void wpa_supplicant_deinit(struct wpa_global *global)
5283 {
5284         int i;
5285
5286         if (global == NULL)
5287                 return;
5288
5289         eloop_cancel_timeout(wpas_periodic, global, NULL);
5290
5291 #ifdef CONFIG_WIFI_DISPLAY
5292         wifi_display_deinit(global);
5293 #endif /* CONFIG_WIFI_DISPLAY */
5294
5295         while (global->ifaces)
5296                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
5297
5298         if (global->ctrl_iface)
5299                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
5300
5301         wpas_notify_supplicant_deinitialized(global);
5302
5303         eap_peer_unregister_methods();
5304 #ifdef CONFIG_AP
5305         eap_server_unregister_methods();
5306 #endif /* CONFIG_AP */
5307
5308         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
5309                 if (!global->drv_priv[i])
5310                         continue;
5311                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
5312         }
5313         os_free(global->drv_priv);
5314
5315         random_deinit();
5316
5317         eloop_destroy();
5318
5319         if (global->params.pid_file) {
5320                 os_daemonize_terminate(global->params.pid_file);
5321                 os_free(global->params.pid_file);
5322         }
5323         os_free(global->params.ctrl_interface);
5324         os_free(global->params.ctrl_interface_group);
5325         os_free(global->params.override_driver);
5326         os_free(global->params.override_ctrl_interface);
5327 #ifdef CONFIG_P2P
5328         os_free(global->params.conf_p2p_dev);
5329 #endif /* CONFIG_P2P */
5330
5331         os_free(global->p2p_disallow_freq.range);
5332         os_free(global->p2p_go_avoid_freq.range);
5333         os_free(global->add_psk);
5334
5335         os_free(global);
5336         wpa_debug_close_syslog();
5337         wpa_debug_close_file();
5338         wpa_debug_close_linux_tracing();
5339 }
5340
5341
5342 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
5343 {
5344         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
5345             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5346                 char country[3];
5347                 country[0] = wpa_s->conf->country[0];
5348                 country[1] = wpa_s->conf->country[1];
5349                 country[2] = '\0';
5350                 if (wpa_drv_set_country(wpa_s, country) < 0) {
5351                         wpa_printf(MSG_ERROR, "Failed to set country code "
5352                                    "'%s'", country);
5353                 }
5354         }
5355
5356         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
5357                 wpas_init_ext_pw(wpa_s);
5358
5359         if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
5360                 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5361
5362 #ifdef CONFIG_WPS
5363         wpas_wps_update_config(wpa_s);
5364 #endif /* CONFIG_WPS */
5365         wpas_p2p_update_config(wpa_s);
5366         wpa_s->conf->changed_parameters = 0;
5367 }
5368
5369
5370 void add_freq(int *freqs, int *num_freqs, int freq)
5371 {
5372         int i;
5373
5374         for (i = 0; i < *num_freqs; i++) {
5375                 if (freqs[i] == freq)
5376                         return;
5377         }
5378
5379         freqs[*num_freqs] = freq;
5380         (*num_freqs)++;
5381 }
5382
5383
5384 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
5385 {
5386         struct wpa_bss *bss, *cbss;
5387         const int max_freqs = 10;
5388         int *freqs;
5389         int num_freqs = 0;
5390
5391         freqs = os_calloc(max_freqs + 1, sizeof(int));
5392         if (freqs == NULL)
5393                 return NULL;
5394
5395         cbss = wpa_s->current_bss;
5396
5397         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
5398                 if (bss == cbss)
5399                         continue;
5400                 if (bss->ssid_len == cbss->ssid_len &&
5401                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
5402                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
5403                         add_freq(freqs, &num_freqs, bss->freq);
5404                         if (num_freqs == max_freqs)
5405                                 break;
5406                 }
5407         }
5408
5409         if (num_freqs == 0) {
5410                 os_free(freqs);
5411                 freqs = NULL;
5412         }
5413
5414         return freqs;
5415 }
5416
5417
5418 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
5419 {
5420         int timeout;
5421         int count;
5422         int *freqs = NULL;
5423
5424         wpas_connect_work_done(wpa_s);
5425
5426         /*
5427          * Remove possible authentication timeout since the connection failed.
5428          */
5429         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
5430
5431         /*
5432          * There is no point in blacklisting the AP if this event is
5433          * generated based on local request to disconnect.
5434          */
5435         if (wpa_s->own_disconnect_req) {
5436                 wpa_s->own_disconnect_req = 0;
5437                 wpa_dbg(wpa_s, MSG_DEBUG,
5438                         "Ignore connection failure due to local request to disconnect");
5439                 return;
5440         }
5441         if (wpa_s->disconnected) {
5442                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
5443                         "indication since interface has been put into "
5444                         "disconnected state");
5445                 return;
5446         }
5447
5448         /*
5449          * Add the failed BSSID into the blacklist and speed up next scan
5450          * attempt if there could be other APs that could accept association.
5451          * The current blacklist count indicates how many times we have tried
5452          * connecting to this AP and multiple attempts mean that other APs are
5453          * either not available or has already been tried, so that we can start
5454          * increasing the delay here to avoid constant scanning.
5455          */
5456         count = wpa_blacklist_add(wpa_s, bssid);
5457         if (count == 1 && wpa_s->current_bss) {
5458                 /*
5459                  * This BSS was not in the blacklist before. If there is
5460                  * another BSS available for the same ESS, we should try that
5461                  * next. Otherwise, we may as well try this one once more
5462                  * before allowing other, likely worse, ESSes to be considered.
5463                  */
5464                 freqs = get_bss_freqs_in_ess(wpa_s);
5465                 if (freqs) {
5466                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
5467                                 "has been seen; try it next");
5468                         wpa_blacklist_add(wpa_s, bssid);
5469                         /*
5470                          * On the next scan, go through only the known channels
5471                          * used in this ESS based on previous scans to speed up
5472                          * common load balancing use case.
5473                          */
5474                         os_free(wpa_s->next_scan_freqs);
5475                         wpa_s->next_scan_freqs = freqs;
5476                 }
5477         }
5478
5479         /*
5480          * Add previous failure count in case the temporary blacklist was
5481          * cleared due to no other BSSes being available.
5482          */
5483         count += wpa_s->extra_blacklist_count;
5484
5485         if (count > 3 && wpa_s->current_ssid) {
5486                 wpa_printf(MSG_DEBUG, "Continuous association failures - "
5487                            "consider temporary network disabling");
5488                 wpas_auth_failed(wpa_s, "CONN_FAILED");
5489         }
5490
5491         switch (count) {
5492         case 1:
5493                 timeout = 100;
5494                 break;
5495         case 2:
5496                 timeout = 500;
5497                 break;
5498         case 3:
5499                 timeout = 1000;
5500                 break;
5501         case 4:
5502                 timeout = 5000;
5503                 break;
5504         default:
5505                 timeout = 10000;
5506                 break;
5507         }
5508
5509         wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
5510                 "ms", count, timeout);
5511
5512         /*
5513          * TODO: if more than one possible AP is available in scan results,
5514          * could try the other ones before requesting a new scan.
5515          */
5516         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
5517                                 1000 * (timeout % 1000));
5518 }
5519
5520
5521 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
5522 {
5523         return wpa_s->conf->ap_scan == 2 ||
5524                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
5525 }
5526
5527
5528 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
5529 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
5530                                               struct wpa_ssid *ssid,
5531                                               const char *field,
5532                                               const char *value)
5533 {
5534 #ifdef IEEE8021X_EAPOL
5535         struct eap_peer_config *eap = &ssid->eap;
5536
5537         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
5538         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
5539                               (const u8 *) value, os_strlen(value));
5540
5541         switch (wpa_supplicant_ctrl_req_from_string(field)) {
5542         case WPA_CTRL_REQ_EAP_IDENTITY:
5543                 os_free(eap->identity);
5544                 eap->identity = (u8 *) os_strdup(value);
5545                 eap->identity_len = os_strlen(value);
5546                 eap->pending_req_identity = 0;
5547                 if (ssid == wpa_s->current_ssid)
5548                         wpa_s->reassociate = 1;
5549                 break;
5550         case WPA_CTRL_REQ_EAP_PASSWORD:
5551                 bin_clear_free(eap->password, eap->password_len);
5552                 eap->password = (u8 *) os_strdup(value);
5553                 eap->password_len = os_strlen(value);
5554                 eap->pending_req_password = 0;
5555                 if (ssid == wpa_s->current_ssid)
5556                         wpa_s->reassociate = 1;
5557                 break;
5558         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
5559                 bin_clear_free(eap->new_password, eap->new_password_len);
5560                 eap->new_password = (u8 *) os_strdup(value);
5561                 eap->new_password_len = os_strlen(value);
5562                 eap->pending_req_new_password = 0;
5563                 if (ssid == wpa_s->current_ssid)
5564                         wpa_s->reassociate = 1;
5565                 break;
5566         case WPA_CTRL_REQ_EAP_PIN:
5567                 str_clear_free(eap->pin);
5568                 eap->pin = os_strdup(value);
5569                 eap->pending_req_pin = 0;
5570                 if (ssid == wpa_s->current_ssid)
5571                         wpa_s->reassociate = 1;
5572                 break;
5573         case WPA_CTRL_REQ_EAP_OTP:
5574                 bin_clear_free(eap->otp, eap->otp_len);
5575                 eap->otp = (u8 *) os_strdup(value);
5576                 eap->otp_len = os_strlen(value);
5577                 os_free(eap->pending_req_otp);
5578                 eap->pending_req_otp = NULL;
5579                 eap->pending_req_otp_len = 0;
5580                 break;
5581         case WPA_CTRL_REQ_EAP_PASSPHRASE:
5582                 str_clear_free(eap->private_key_passwd);
5583                 eap->private_key_passwd = os_strdup(value);
5584                 eap->pending_req_passphrase = 0;
5585                 if (ssid == wpa_s->current_ssid)
5586                         wpa_s->reassociate = 1;
5587                 break;
5588         case WPA_CTRL_REQ_SIM:
5589                 str_clear_free(eap->external_sim_resp);
5590                 eap->external_sim_resp = os_strdup(value);
5591                 break;
5592         case WPA_CTRL_REQ_PSK_PASSPHRASE:
5593                 if (wpa_config_set(ssid, "psk", value, 0) < 0)
5594                         return -1;
5595                 ssid->mem_only_psk = 1;
5596                 if (ssid->passphrase)
5597                         wpa_config_update_psk(ssid);
5598                 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
5599                         wpa_supplicant_req_scan(wpa_s, 0, 0);
5600                 break;
5601         case WPA_CTRL_REQ_EXT_CERT_CHECK:
5602                 if (eap->pending_ext_cert_check != PENDING_CHECK)
5603                         return -1;
5604                 if (os_strcmp(value, "good") == 0)
5605                         eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD;
5606                 else if (os_strcmp(value, "bad") == 0)
5607                         eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD;
5608                 else
5609                         return -1;
5610                 break;
5611         default:
5612                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
5613                 return -1;
5614         }
5615
5616         return 0;
5617 #else /* IEEE8021X_EAPOL */
5618         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
5619         return -1;
5620 #endif /* IEEE8021X_EAPOL */
5621 }
5622 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
5623
5624
5625 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5626 {
5627         int i;
5628         unsigned int drv_enc;
5629
5630         if (wpa_s->p2p_mgmt)
5631                 return 1; /* no normal network profiles on p2p_mgmt interface */
5632
5633         if (ssid == NULL)
5634                 return 1;
5635
5636         if (ssid->disabled)
5637                 return 1;
5638
5639         if (wpa_s->drv_capa_known)
5640                 drv_enc = wpa_s->drv_enc;
5641         else
5642                 drv_enc = (unsigned int) -1;
5643
5644         for (i = 0; i < NUM_WEP_KEYS; i++) {
5645                 size_t len = ssid->wep_key_len[i];
5646                 if (len == 0)
5647                         continue;
5648                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
5649                         continue;
5650                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
5651                         continue;
5652                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
5653                         continue;
5654                 return 1; /* invalid WEP key */
5655         }
5656
5657         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
5658             (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk &&
5659             !ssid->mem_only_psk)
5660                 return 1;
5661
5662         return 0;
5663 }
5664
5665
5666 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5667 {
5668 #ifdef CONFIG_IEEE80211W
5669         if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) {
5670                 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
5671                     !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
5672                         /*
5673                          * Driver does not support BIP -- ignore pmf=1 default
5674                          * since the connection with PMF would fail and the
5675                          * configuration does not require PMF to be enabled.
5676                          */
5677                         return NO_MGMT_FRAME_PROTECTION;
5678                 }
5679
5680                 return wpa_s->conf->pmf;
5681         }
5682
5683         return ssid->ieee80211w;
5684 #else /* CONFIG_IEEE80211W */
5685         return NO_MGMT_FRAME_PROTECTION;
5686 #endif /* CONFIG_IEEE80211W */
5687 }
5688
5689
5690 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
5691 {
5692         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
5693                 return 1;
5694         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
5695                 return 0;
5696         return -1;
5697 }
5698
5699
5700 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
5701 {
5702         struct wpa_ssid *ssid = wpa_s->current_ssid;
5703         int dur;
5704         struct os_reltime now;
5705
5706         if (ssid == NULL) {
5707                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
5708                            "SSID block");
5709                 return;
5710         }
5711
5712         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
5713                 return;
5714
5715         ssid->auth_failures++;
5716
5717 #ifdef CONFIG_P2P
5718         if (ssid->p2p_group &&
5719             (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
5720                 /*
5721                  * Skip the wait time since there is a short timeout on the
5722                  * connection to a P2P group.
5723                  */
5724                 return;
5725         }
5726 #endif /* CONFIG_P2P */
5727
5728         if (ssid->auth_failures > 50)
5729                 dur = 300;
5730         else if (ssid->auth_failures > 10)
5731                 dur = 120;
5732         else if (ssid->auth_failures > 5)
5733                 dur = 90;
5734         else if (ssid->auth_failures > 3)
5735                 dur = 60;
5736         else if (ssid->auth_failures > 2)
5737                 dur = 30;
5738         else if (ssid->auth_failures > 1)
5739                 dur = 20;
5740         else
5741                 dur = 10;
5742
5743         if (ssid->auth_failures > 1 &&
5744             wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
5745                 dur += os_random() % (ssid->auth_failures * 10);
5746
5747         os_get_reltime(&now);
5748         if (now.sec + dur <= ssid->disabled_until.sec)
5749                 return;
5750
5751         ssid->disabled_until.sec = now.sec + dur;
5752
5753         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
5754                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
5755                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
5756                 ssid->auth_failures, dur, reason);
5757 }
5758
5759
5760 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
5761                               struct wpa_ssid *ssid, int clear_failures)
5762 {
5763         if (ssid == NULL)
5764                 return;
5765
5766         if (ssid->disabled_until.sec) {
5767                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
5768                         "id=%d ssid=\"%s\"",
5769                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
5770         }
5771         ssid->disabled_until.sec = 0;
5772         ssid->disabled_until.usec = 0;
5773         if (clear_failures)
5774                 ssid->auth_failures = 0;
5775 }
5776
5777
5778 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
5779 {
5780         size_t i;
5781
5782         if (wpa_s->disallow_aps_bssid == NULL)
5783                 return 0;
5784
5785         for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
5786                 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
5787                               bssid, ETH_ALEN) == 0)
5788                         return 1;
5789         }
5790
5791         return 0;
5792 }
5793
5794
5795 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
5796                     size_t ssid_len)
5797 {
5798         size_t i;
5799
5800         if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
5801                 return 0;
5802
5803         for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
5804                 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
5805                 if (ssid_len == s->ssid_len &&
5806                     os_memcmp(ssid, s->ssid, ssid_len) == 0)
5807                         return 1;
5808         }
5809
5810         return 0;
5811 }
5812
5813
5814 /**
5815  * wpas_request_connection - Request a new connection
5816  * @wpa_s: Pointer to the network interface
5817  *
5818  * This function is used to request a new connection to be found. It will mark
5819  * the interface to allow reassociation and request a new scan to find a
5820  * suitable network to connect to.
5821  */
5822 void wpas_request_connection(struct wpa_supplicant *wpa_s)
5823 {
5824         wpa_s->normal_scans = 0;
5825         wpa_s->scan_req = NORMAL_SCAN_REQ;
5826         wpa_supplicant_reinit_autoscan(wpa_s);
5827         wpa_s->extra_blacklist_count = 0;
5828         wpa_s->disconnected = 0;
5829         wpa_s->reassociate = 1;
5830
5831         if (wpa_supplicant_fast_associate(wpa_s) != 1)
5832                 wpa_supplicant_req_scan(wpa_s, 0, 0);
5833         else
5834                 wpa_s->reattach = 0;
5835 }
5836
5837
5838 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
5839                     struct wpa_used_freq_data *freqs_data,
5840                     unsigned int len)
5841 {
5842         unsigned int i;
5843
5844         wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
5845                 len, title);
5846         for (i = 0; i < len; i++) {
5847                 struct wpa_used_freq_data *cur = &freqs_data[i];
5848                 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
5849                         i, cur->freq, cur->flags);
5850         }
5851 }
5852
5853
5854 /*
5855  * Find the operating frequencies of any of the virtual interfaces that
5856  * are using the same radio as the current interface, and in addition, get
5857  * information about the interface types that are using the frequency.
5858  */
5859 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
5860                                 struct wpa_used_freq_data *freqs_data,
5861                                 unsigned int len)
5862 {
5863         struct wpa_supplicant *ifs;
5864         u8 bssid[ETH_ALEN];
5865         int freq;
5866         unsigned int idx = 0, i;
5867
5868         wpa_dbg(wpa_s, MSG_DEBUG,
5869                 "Determining shared radio frequencies (max len %u)", len);
5870         os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
5871
5872         dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
5873                          radio_list) {
5874                 if (idx == len)
5875                         break;
5876
5877                 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
5878                         continue;
5879
5880                 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
5881                     ifs->current_ssid->mode == WPAS_MODE_P2P_GO ||
5882                     ifs->current_ssid->mode == WPAS_MODE_MESH)
5883                         freq = ifs->current_ssid->frequency;
5884                 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
5885                         freq = ifs->assoc_freq;
5886                 else
5887                         continue;
5888
5889                 /* Hold only distinct freqs */
5890                 for (i = 0; i < idx; i++)
5891                         if (freqs_data[i].freq == freq)
5892                                 break;
5893
5894                 if (i == idx)
5895                         freqs_data[idx++].freq = freq;
5896
5897                 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
5898                         freqs_data[i].flags |= ifs->current_ssid->p2p_group ?
5899                                 WPA_FREQ_USED_BY_P2P_CLIENT :
5900                                 WPA_FREQ_USED_BY_INFRA_STATION;
5901                 }
5902         }
5903
5904         dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
5905         return idx;
5906 }
5907
5908
5909 /*
5910  * Find the operating frequencies of any of the virtual interfaces that
5911  * are using the same radio as the current interface.
5912  */
5913 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
5914                            int *freq_array, unsigned int len)
5915 {
5916         struct wpa_used_freq_data *freqs_data;
5917         int num, i;
5918
5919         os_memset(freq_array, 0, sizeof(int) * len);
5920
5921         freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
5922         if (!freqs_data)
5923                 return -1;
5924
5925         num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
5926         for (i = 0; i < num; i++)
5927                 freq_array[i] = freqs_data[i].freq;
5928
5929         os_free(freqs_data);
5930
5931         return num;
5932 }
5933
5934
5935 static void wpas_rrm_neighbor_rep_timeout_handler(void *data, void *user_ctx)
5936 {
5937         struct rrm_data *rrm = data;
5938
5939         if (!rrm->notify_neighbor_rep) {
5940                 wpa_printf(MSG_ERROR,
5941                            "RRM: Unexpected neighbor report timeout");
5942                 return;
5943         }
5944
5945         wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report - NONE");
5946         rrm->notify_neighbor_rep(rrm->neighbor_rep_cb_ctx, NULL);
5947
5948         rrm->notify_neighbor_rep = NULL;
5949         rrm->neighbor_rep_cb_ctx = NULL;
5950 }
5951
5952
5953 /*
5954  * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant
5955  * @wpa_s: Pointer to wpa_supplicant
5956  */
5957 void wpas_rrm_reset(struct wpa_supplicant *wpa_s)
5958 {
5959         wpa_s->rrm.rrm_used = 0;
5960
5961         eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
5962                              NULL);
5963         if (wpa_s->rrm.notify_neighbor_rep)
5964                 wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL);
5965         wpa_s->rrm.next_neighbor_rep_token = 1;
5966 }
5967
5968
5969 /*
5970  * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
5971  * @wpa_s: Pointer to wpa_supplicant
5972  * @report: Neighbor report buffer, prefixed by a 1-byte dialog token
5973  * @report_len: Length of neighbor report buffer
5974  */
5975 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s,
5976                                    const u8 *report, size_t report_len)
5977 {
5978         struct wpabuf *neighbor_rep;
5979
5980         wpa_hexdump(MSG_DEBUG, "RRM: New Neighbor Report", report, report_len);
5981         if (report_len < 1)
5982                 return;
5983
5984         if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
5985                 wpa_printf(MSG_DEBUG,
5986                            "RRM: Discarding neighbor report with token %d (expected %d)",
5987                            report[0], wpa_s->rrm.next_neighbor_rep_token - 1);
5988                 return;
5989         }
5990
5991         eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
5992                              NULL);
5993
5994         if (!wpa_s->rrm.notify_neighbor_rep) {
5995                 wpa_printf(MSG_ERROR, "RRM: Unexpected neighbor report");
5996                 return;
5997         }
5998
5999         /* skipping the first byte, which is only an id (dialog token) */
6000         neighbor_rep = wpabuf_alloc(report_len - 1);
6001         if (neighbor_rep == NULL)
6002                 return;
6003         wpabuf_put_data(neighbor_rep, report + 1, report_len - 1);
6004         wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)",
6005                    report[0]);
6006         wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
6007                                        neighbor_rep);
6008         wpa_s->rrm.notify_neighbor_rep = NULL;
6009         wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
6010 }
6011
6012
6013 #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
6014 /* Workaround different, undefined for Windows, error codes used here */
6015 #define ENOTCONN -1
6016 #define EOPNOTSUPP -1
6017 #define ECANCELED -1
6018 #endif
6019
6020 /**
6021  * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP
6022  * @wpa_s: Pointer to wpa_supplicant
6023  * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE
6024  *        is sent in the request.
6025  * @cb: Callback function to be called once the requested report arrives, or
6026  *      timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds.
6027  *      In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's
6028  *      the requester's responsibility to free it.
6029  *      In the latter case NULL will be sent in 'neighbor_rep'.
6030  * @cb_ctx: Context value to send the callback function
6031  * Returns: 0 in case of success, negative error code otherwise
6032  *
6033  * In case there is a previous request which has not been answered yet, the
6034  * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT.
6035  * Request must contain a callback function.
6036  */
6037 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s,
6038                                        const struct wpa_ssid *ssid,
6039                                        void (*cb)(void *ctx,
6040                                                   struct wpabuf *neighbor_rep),
6041                                        void *cb_ctx)
6042 {
6043         struct wpabuf *buf;
6044         const u8 *rrm_ie;
6045
6046         if (wpa_s->wpa_state != WPA_COMPLETED || wpa_s->current_ssid == NULL) {
6047                 wpa_printf(MSG_DEBUG, "RRM: No connection, no RRM.");
6048                 return -ENOTCONN;
6049         }
6050
6051         if (!wpa_s->rrm.rrm_used) {
6052                 wpa_printf(MSG_DEBUG, "RRM: No RRM in current connection.");
6053                 return -EOPNOTSUPP;
6054         }
6055
6056         rrm_ie = wpa_bss_get_ie(wpa_s->current_bss,
6057                                 WLAN_EID_RRM_ENABLED_CAPABILITIES);
6058         if (!rrm_ie || !(wpa_s->current_bss->caps & IEEE80211_CAP_RRM) ||
6059             !(rrm_ie[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
6060                 wpa_printf(MSG_DEBUG,
6061                            "RRM: No network support for Neighbor Report.");
6062                 return -EOPNOTSUPP;
6063         }
6064
6065         if (!cb) {
6066                 wpa_printf(MSG_DEBUG,
6067                            "RRM: Neighbor Report request must provide a callback.");
6068                 return -EINVAL;
6069         }
6070
6071         /* Refuse if there's a live request */
6072         if (wpa_s->rrm.notify_neighbor_rep) {
6073                 wpa_printf(MSG_DEBUG,
6074                            "RRM: Currently handling previous Neighbor Report.");
6075                 return -EBUSY;
6076         }
6077
6078         /* 3 = action category + action code + dialog token */
6079         buf = wpabuf_alloc(3 + (ssid ? 2 + ssid->ssid_len : 0));
6080         if (buf == NULL) {
6081                 wpa_printf(MSG_DEBUG,
6082                            "RRM: Failed to allocate Neighbor Report Request");
6083                 return -ENOMEM;
6084         }
6085
6086         wpa_printf(MSG_DEBUG, "RRM: Neighbor report request (for %s), token=%d",
6087                    (ssid ? wpa_ssid_txt(ssid->ssid, ssid->ssid_len) : ""),
6088                    wpa_s->rrm.next_neighbor_rep_token);
6089
6090         wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6091         wpabuf_put_u8(buf, WLAN_RRM_NEIGHBOR_REPORT_REQUEST);
6092         wpabuf_put_u8(buf, wpa_s->rrm.next_neighbor_rep_token);
6093         if (ssid) {
6094                 wpabuf_put_u8(buf, WLAN_EID_SSID);
6095                 wpabuf_put_u8(buf, ssid->ssid_len);
6096                 wpabuf_put_data(buf, ssid->ssid, ssid->ssid_len);
6097         }
6098
6099         wpa_s->rrm.next_neighbor_rep_token++;
6100
6101         if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
6102                                 wpa_s->own_addr, wpa_s->bssid,
6103                                 wpabuf_head(buf), wpabuf_len(buf), 0) < 0) {
6104                 wpa_printf(MSG_DEBUG,
6105                            "RRM: Failed to send Neighbor Report Request");
6106                 wpabuf_free(buf);
6107                 return -ECANCELED;
6108         }
6109
6110         wpa_s->rrm.neighbor_rep_cb_ctx = cb_ctx;
6111         wpa_s->rrm.notify_neighbor_rep = cb;
6112         eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT, 0,
6113                                wpas_rrm_neighbor_rep_timeout_handler,
6114                                &wpa_s->rrm, NULL);
6115
6116         wpabuf_free(buf);
6117         return 0;
6118 }
6119
6120
6121 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s,
6122                                               const u8 *src,
6123                                               const u8 *frame, size_t len,
6124                                               int rssi)
6125 {
6126         struct wpabuf *buf;
6127         const struct rrm_link_measurement_request *req;
6128         struct rrm_link_measurement_report report;
6129
6130         if (wpa_s->wpa_state != WPA_COMPLETED) {
6131                 wpa_printf(MSG_INFO,
6132                            "RRM: Ignoring link measurement request. Not associated");
6133                 return;
6134         }
6135
6136         if (!wpa_s->rrm.rrm_used) {
6137                 wpa_printf(MSG_INFO,
6138                            "RRM: Ignoring link measurement request. Not RRM network");
6139                 return;
6140         }
6141
6142         if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION)) {
6143                 wpa_printf(MSG_INFO,
6144                            "RRM: Measurement report failed. TX power insertion not supported");
6145                 return;
6146         }
6147
6148         req = (const struct rrm_link_measurement_request *) frame;
6149         if (len < sizeof(*req)) {
6150                 wpa_printf(MSG_INFO,
6151                            "RRM: Link measurement report failed. Request too short");
6152                 return;
6153         }
6154
6155         os_memset(&report, 0, sizeof(report));
6156         report.tpc.eid = WLAN_EID_TPC_REPORT;
6157         report.tpc.len = 2;
6158         report.rsni = 255; /* 255 indicates that RSNI is not available */
6159         report.dialog_token = req->dialog_token;
6160
6161         /*
6162          * It's possible to estimate RCPI based on RSSI in dBm. This
6163          * calculation will not reflect the correct value for high rates,
6164          * but it's good enough for Action frames which are transmitted
6165          * with up to 24 Mbps rates.
6166          */
6167         if (!rssi)
6168                 report.rcpi = 255; /* not available */
6169         else if (rssi < -110)
6170                 report.rcpi = 0;
6171         else if (rssi > 0)
6172                 report.rcpi = 220;
6173         else
6174                 report.rcpi = (rssi + 110) * 2;
6175
6176         /* action_category + action_code */
6177         buf = wpabuf_alloc(2 + sizeof(report));
6178         if (buf == NULL) {
6179                 wpa_printf(MSG_ERROR,
6180                            "RRM: Link measurement report failed. Buffer allocation failed");
6181                 return;
6182         }
6183
6184         wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6185         wpabuf_put_u8(buf, WLAN_RRM_LINK_MEASUREMENT_REPORT);
6186         wpabuf_put_data(buf, &report, sizeof(report));
6187         wpa_hexdump(MSG_DEBUG, "RRM: Link measurement report:",
6188                     wpabuf_head(buf), wpabuf_len(buf));
6189
6190         if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6191                                 wpa_s->own_addr, wpa_s->bssid,
6192                                 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6193                 wpa_printf(MSG_ERROR,
6194                            "RRM: Link measurement report failed. Send action failed");
6195         }
6196         wpabuf_free(buf);
6197 }
6198
6199
6200 struct wpa_supplicant *
6201 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
6202 {
6203         switch (frame) {
6204 #ifdef CONFIG_P2P
6205         case VENDOR_ELEM_PROBE_REQ_P2P:
6206         case VENDOR_ELEM_PROBE_RESP_P2P:
6207         case VENDOR_ELEM_PROBE_RESP_P2P_GO:
6208         case VENDOR_ELEM_BEACON_P2P_GO:
6209         case VENDOR_ELEM_P2P_PD_REQ:
6210         case VENDOR_ELEM_P2P_PD_RESP:
6211         case VENDOR_ELEM_P2P_GO_NEG_REQ:
6212         case VENDOR_ELEM_P2P_GO_NEG_RESP:
6213         case VENDOR_ELEM_P2P_GO_NEG_CONF:
6214         case VENDOR_ELEM_P2P_INV_REQ:
6215         case VENDOR_ELEM_P2P_INV_RESP:
6216         case VENDOR_ELEM_P2P_ASSOC_REQ:
6217         case VENDOR_ELEM_P2P_ASSOC_RESP:
6218                 return wpa_s->parent;
6219 #endif /* CONFIG_P2P */
6220         default:
6221                 return wpa_s;
6222         }
6223 }
6224
6225
6226 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
6227 {
6228         unsigned int i;
6229         char buf[30];
6230
6231         wpa_printf(MSG_DEBUG, "Update vendor elements");
6232
6233         for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
6234                 if (wpa_s->vendor_elem[i]) {
6235                         int res;
6236
6237                         res = os_snprintf(buf, sizeof(buf), "frame[%u]", i);
6238                         if (!os_snprintf_error(sizeof(buf), res)) {
6239                                 wpa_hexdump_buf(MSG_DEBUG, buf,
6240                                                 wpa_s->vendor_elem[i]);
6241                         }
6242                 }
6243         }
6244
6245 #ifdef CONFIG_P2P
6246         if (wpa_s->parent == wpa_s &&
6247             wpa_s->global->p2p &&
6248             !wpa_s->global->p2p_disabled)
6249                 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
6250 #endif /* CONFIG_P2P */
6251 }
6252
6253
6254 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
6255                             const u8 *elem, size_t len)
6256 {
6257         u8 *ie, *end;
6258
6259         ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
6260         end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
6261
6262         for (; ie + 1 < end; ie += 2 + ie[1]) {
6263                 if (ie + len > end)
6264                         break;
6265                 if (os_memcmp(ie, elem, len) != 0)
6266                         continue;
6267
6268                 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
6269                         wpabuf_free(wpa_s->vendor_elem[frame]);
6270                         wpa_s->vendor_elem[frame] = NULL;
6271                 } else {
6272                         os_memmove(ie, ie + len, end - (ie + len));
6273                         wpa_s->vendor_elem[frame]->used -= len;
6274                 }
6275                 wpas_vendor_elem_update(wpa_s);
6276                 return 0;
6277         }
6278
6279         return -1;
6280 }
6281
6282
6283 struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
6284                                    u16 num_modes, enum hostapd_hw_mode mode)
6285 {
6286         u16 i;
6287
6288         for (i = 0; i < num_modes; i++) {
6289                 if (modes[i].mode == mode)
6290                         return &modes[i];
6291         }
6292
6293         return NULL;
6294 }