wpa_supplicant/wpa_supplicant.c

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