wpa_supplicant/wpa_supplicant.c

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