wpa_supplicant/wpa_supplicant.c

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