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