wpa_supplicant/wpa_supplicant.c

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