wpa_supplicant/wpa_supplicant.c

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