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