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                 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1918         }
1919         wpa_s->connect_without_scan = NULL;
1920         wpa_s->disconnected = 0;
1921         wpa_s->reassociate = 1;
1922
1923         if (wpa_supplicant_fast_associate(wpa_s) != 1)
1924                 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
1925
1926         if (ssid)
1927                 wpas_notify_network_selected(wpa_s, ssid);
1928 }
1929
1930
1931 /**
1932  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1933  * @wpa_s: wpa_supplicant structure for a network interface
1934  * @ap_scan: AP scan mode
1935  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1936  *
1937  */
1938 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1939 {
1940
1941         int old_ap_scan;
1942
1943         if (ap_scan < 0 || ap_scan > 2)
1944                 return -1;
1945
1946 #ifdef ANDROID
1947         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
1948             wpa_s->wpa_state >= WPA_ASSOCIATING &&
1949             wpa_s->wpa_state < WPA_COMPLETED) {
1950                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
1951                            "associating", wpa_s->conf->ap_scan, ap_scan);
1952                 return 0;
1953         }
1954 #endif /* ANDROID */
1955
1956         old_ap_scan = wpa_s->conf->ap_scan;
1957         wpa_s->conf->ap_scan = ap_scan;
1958
1959         if (old_ap_scan != wpa_s->conf->ap_scan)
1960                 wpas_notify_ap_scan_changed(wpa_s);
1961
1962         return 0;
1963 }
1964
1965
1966 /**
1967  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
1968  * @wpa_s: wpa_supplicant structure for a network interface
1969  * @expire_age: Expiration age in seconds
1970  * Returns: 0 if succeed or -1 if expire_age has an invalid value
1971  *
1972  */
1973 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
1974                                           unsigned int bss_expire_age)
1975 {
1976         if (bss_expire_age < 10) {
1977                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
1978                         bss_expire_age);
1979                 return -1;
1980         }
1981         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
1982                 bss_expire_age);
1983         wpa_s->conf->bss_expiration_age = bss_expire_age;
1984
1985         return 0;
1986 }
1987
1988
1989 /**
1990  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
1991  * @wpa_s: wpa_supplicant structure for a network interface
1992  * @expire_count: number of scans after which an unseen BSS is reclaimed
1993  * Returns: 0 if succeed or -1 if expire_count has an invalid value
1994  *
1995  */
1996 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
1997                                             unsigned int bss_expire_count)
1998 {
1999         if (bss_expire_count < 1) {
2000                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2001                         bss_expire_count);
2002                 return -1;
2003         }
2004         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2005                 bss_expire_count);
2006         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2007
2008         return 0;
2009 }
2010
2011
2012 /**
2013  * wpa_supplicant_set_scan_interval - Set scan interval
2014  * @wpa_s: wpa_supplicant structure for a network interface
2015  * @scan_interval: scan interval in seconds
2016  * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2017  *
2018  */
2019 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2020                                      int scan_interval)
2021 {
2022         if (scan_interval < 0) {
2023                 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2024                         scan_interval);
2025                 return -1;
2026         }
2027         wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2028                 scan_interval);
2029         wpa_supplicant_update_scan_int(wpa_s, scan_interval);
2030
2031         return 0;
2032 }
2033
2034
2035 /**
2036  * wpa_supplicant_set_debug_params - Set global debug params
2037  * @global: wpa_global structure
2038  * @debug_level: debug level
2039  * @debug_timestamp: determines if show timestamp in debug data
2040  * @debug_show_keys: determines if show keys in debug data
2041  * Returns: 0 if succeed or -1 if debug_level has wrong value
2042  */
2043 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
2044                                     int debug_timestamp, int debug_show_keys)
2045 {
2046
2047         int old_level, old_timestamp, old_show_keys;
2048
2049         /* check for allowed debuglevels */
2050         if (debug_level != MSG_EXCESSIVE &&
2051             debug_level != MSG_MSGDUMP &&
2052             debug_level != MSG_DEBUG &&
2053             debug_level != MSG_INFO &&
2054             debug_level != MSG_WARNING &&
2055             debug_level != MSG_ERROR)
2056                 return -1;
2057
2058         old_level = wpa_debug_level;
2059         old_timestamp = wpa_debug_timestamp;
2060         old_show_keys = wpa_debug_show_keys;
2061
2062         wpa_debug_level = debug_level;
2063         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2064         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2065
2066         if (wpa_debug_level != old_level)
2067                 wpas_notify_debug_level_changed(global);
2068         if (wpa_debug_timestamp != old_timestamp)
2069                 wpas_notify_debug_timestamp_changed(global);
2070         if (wpa_debug_show_keys != old_show_keys)
2071                 wpas_notify_debug_show_keys_changed(global);
2072
2073         return 0;
2074 }
2075
2076
2077 /**
2078  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2079  * @wpa_s: Pointer to wpa_supplicant data
2080  * Returns: A pointer to the current network structure or %NULL on failure
2081  */
2082 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2083 {
2084         struct wpa_ssid *entry;
2085         u8 ssid[MAX_SSID_LEN];
2086         int res;
2087         size_t ssid_len;
2088         u8 bssid[ETH_ALEN];
2089         int wired;
2090
2091         res = wpa_drv_get_ssid(wpa_s, ssid);
2092         if (res < 0) {
2093                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2094                         "driver");
2095                 return NULL;
2096         }
2097         ssid_len = res;
2098
2099         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2100                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2101                         "driver");
2102                 return NULL;
2103         }
2104
2105         wired = wpa_s->conf->ap_scan == 0 &&
2106                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2107
2108         entry = wpa_s->conf->ssid;
2109         while (entry) {
2110                 if (!wpas_network_disabled(wpa_s, entry) &&
2111                     ((ssid_len == entry->ssid_len &&
2112                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2113                     (!entry->bssid_set ||
2114                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2115                         return entry;
2116 #ifdef CONFIG_WPS
2117                 if (!wpas_network_disabled(wpa_s, entry) &&
2118                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2119                     (entry->ssid == NULL || entry->ssid_len == 0) &&
2120                     (!entry->bssid_set ||
2121                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2122                         return entry;
2123 #endif /* CONFIG_WPS */
2124
2125                 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2126                     entry->ssid_len == 0 &&
2127                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2128                         return entry;
2129
2130                 entry = entry->next;
2131         }
2132
2133         return NULL;
2134 }
2135
2136
2137 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2138 {
2139         struct wpa_global *global = wpa_s->global;
2140
2141         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2142                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2143                 if (global->drv_priv[i] == NULL) {
2144                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2145                                    "'%s'", wpa_drivers[i]->name);
2146                         return -1;
2147                 }
2148         }
2149
2150         wpa_s->driver = wpa_drivers[i];
2151         wpa_s->global_drv_priv = global->drv_priv[i];
2152
2153         return 0;
2154 }
2155
2156
2157 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2158                                      const char *name)
2159 {
2160         int i;
2161         size_t len;
2162         const char *pos, *driver = name;
2163
2164         if (wpa_s == NULL)
2165                 return -1;
2166
2167         if (wpa_drivers[0] == NULL) {
2168                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2169                         "wpa_supplicant");
2170                 return -1;
2171         }
2172
2173         if (name == NULL) {
2174                 /* default to first driver in the list */
2175                 return select_driver(wpa_s, 0);
2176         }
2177
2178         do {
2179                 pos = os_strchr(driver, ',');
2180                 if (pos)
2181                         len = pos - driver;
2182                 else
2183                         len = os_strlen(driver);
2184
2185                 for (i = 0; wpa_drivers[i]; i++) {
2186                         if (os_strlen(wpa_drivers[i]->name) == len &&
2187                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
2188                             0) {
2189                                 /* First driver that succeeds wins */
2190                                 if (select_driver(wpa_s, i) == 0)
2191                                         return 0;
2192                         }
2193                 }
2194
2195                 driver = pos + 1;
2196         } while (pos);
2197
2198         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2199         return -1;
2200 }
2201
2202
2203 /**
2204  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2205  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2206  *      with struct wpa_driver_ops::init()
2207  * @src_addr: Source address of the EAPOL frame
2208  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2209  * @len: Length of the EAPOL data
2210  *
2211  * This function is called for each received EAPOL frame. Most driver
2212  * interfaces rely on more generic OS mechanism for receiving frames through
2213  * l2_packet, but if such a mechanism is not available, the driver wrapper may
2214  * take care of received EAPOL frames and deliver them to the core supplicant
2215  * code by calling this function.
2216  */
2217 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
2218                              const u8 *buf, size_t len)
2219 {
2220         struct wpa_supplicant *wpa_s = ctx;
2221
2222         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2223         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
2224
2225         if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2226             (wpa_s->last_eapol_matches_bssid &&
2227 #ifdef CONFIG_AP
2228              !wpa_s->ap_iface &&
2229 #endif /* CONFIG_AP */
2230              os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
2231                 /*
2232                  * There is possible race condition between receiving the
2233                  * association event and the EAPOL frame since they are coming
2234                  * through different paths from the driver. In order to avoid
2235                  * issues in trying to process the EAPOL frame before receiving
2236                  * association information, lets queue it for processing until
2237                  * the association event is received. This may also be needed in
2238                  * driver-based roaming case, so also use src_addr != BSSID as a
2239                  * trigger if we have previously confirmed that the
2240                  * Authenticator uses BSSID as the src_addr (which is not the
2241                  * case with wired IEEE 802.1X).
2242                  */
2243                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2244                         "of received EAPOL frame (state=%s bssid=" MACSTR ")",
2245                         wpa_supplicant_state_txt(wpa_s->wpa_state),
2246                         MAC2STR(wpa_s->bssid));
2247                 wpabuf_free(wpa_s->pending_eapol_rx);
2248                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2249                 if (wpa_s->pending_eapol_rx) {
2250                         os_get_time(&wpa_s->pending_eapol_rx_time);
2251                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2252                                   ETH_ALEN);
2253                 }
2254                 return;
2255         }
2256
2257         wpa_s->last_eapol_matches_bssid =
2258                 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2259
2260 #ifdef CONFIG_AP
2261         if (wpa_s->ap_iface) {
2262                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2263                 return;
2264         }
2265 #endif /* CONFIG_AP */
2266
2267         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2268                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2269                         "no key management is configured");
2270                 return;
2271         }
2272
2273         if (wpa_s->eapol_received == 0 &&
2274             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2275              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2276              wpa_s->wpa_state != WPA_COMPLETED) &&
2277             (wpa_s->current_ssid == NULL ||
2278              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2279                 /* Timeout for completing IEEE 802.1X and WPA authentication */
2280                 wpa_supplicant_req_auth_timeout(
2281                         wpa_s,
2282                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2283                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2284                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2285                         70 : 10, 0);
2286         }
2287         wpa_s->eapol_received++;
2288
2289         if (wpa_s->countermeasures) {
2290                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2291                         "EAPOL packet");
2292                 return;
2293         }
2294
2295 #ifdef CONFIG_IBSS_RSN
2296         if (wpa_s->current_ssid &&
2297             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2298                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2299                 return;
2300         }
2301 #endif /* CONFIG_IBSS_RSN */
2302
2303         /* Source address of the incoming EAPOL frame could be compared to the
2304          * current BSSID. However, it is possible that a centralized
2305          * Authenticator could be using another MAC address than the BSSID of
2306          * an AP, so just allow any address to be used for now. The replies are
2307          * still sent to the current BSSID (if available), though. */
2308
2309         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2310         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2311             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2312                 return;
2313         wpa_drv_poll(wpa_s);
2314         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2315                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2316         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2317                 /*
2318                  * Set portValid = TRUE here since we are going to skip 4-way
2319                  * handshake processing which would normally set portValid. We
2320                  * need this to allow the EAPOL state machines to be completed
2321                  * without going through EAPOL-Key handshake.
2322                  */
2323                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2324         }
2325 }
2326
2327
2328 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2329 {
2330         if (wpa_s->driver->send_eapol) {
2331                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2332                 if (addr)
2333                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2334         } else if ((!wpa_s->p2p_mgmt ||
2335                     !(wpa_s->drv_flags &
2336                       WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
2337                    !(wpa_s->drv_flags &
2338                      WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
2339                 l2_packet_deinit(wpa_s->l2);
2340                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2341                                            wpa_drv_get_mac_addr(wpa_s),
2342                                            ETH_P_EAPOL,
2343                                            wpa_supplicant_rx_eapol, wpa_s, 0);
2344                 if (wpa_s->l2 == NULL)
2345                         return -1;
2346         } else {
2347                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2348                 if (addr)
2349                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2350         }
2351
2352         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2353                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2354                 return -1;
2355         }
2356
2357         return 0;
2358 }
2359
2360
2361 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
2362                                            const u8 *buf, size_t len)
2363 {
2364         struct wpa_supplicant *wpa_s = ctx;
2365         const struct l2_ethhdr *eth;
2366
2367         if (len < sizeof(*eth))
2368                 return;
2369         eth = (const struct l2_ethhdr *) buf;
2370
2371         if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2372             !(eth->h_dest[0] & 0x01)) {
2373                 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2374                         " (bridge - not for this interface - ignore)",
2375                         MAC2STR(src_addr), MAC2STR(eth->h_dest));
2376                 return;
2377         }
2378
2379         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2380                 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
2381         wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2382                                 len - sizeof(*eth));
2383 }
2384
2385
2386 /**
2387  * wpa_supplicant_driver_init - Initialize driver interface parameters
2388  * @wpa_s: Pointer to wpa_supplicant data
2389  * Returns: 0 on success, -1 on failure
2390  *
2391  * This function is called to initialize driver interface parameters.
2392  * wpa_drv_init() must have been called before this function to initialize the
2393  * driver interface.
2394  */
2395 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2396 {
2397         static int interface_count = 0;
2398
2399         if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2400                 return -1;
2401
2402         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2403                 MAC2STR(wpa_s->own_addr));
2404         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2405
2406         if (wpa_s->bridge_ifname[0]) {
2407                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2408                         "interface '%s'", wpa_s->bridge_ifname);
2409                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2410                                               wpa_s->own_addr,
2411                                               ETH_P_EAPOL,
2412                                               wpa_supplicant_rx_eapol_bridge,
2413                                               wpa_s, 1);
2414                 if (wpa_s->l2_br == NULL) {
2415                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2416                                 "connection for the bridge interface '%s'",
2417                                 wpa_s->bridge_ifname);
2418                         return -1;
2419                 }
2420         }
2421
2422         wpa_clear_keys(wpa_s, NULL);
2423
2424         /* Make sure that TKIP countermeasures are not left enabled (could
2425          * happen if wpa_supplicant is killed during countermeasures. */
2426         wpa_drv_set_countermeasures(wpa_s, 0);
2427
2428         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2429         wpa_drv_flush_pmkid(wpa_s);
2430
2431         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2432         wpa_s->prev_scan_wildcard = 0;
2433
2434         if (wpa_supplicant_enabled_networks(wpa_s)) {
2435                 if (wpa_supplicant_delayed_sched_scan(wpa_s, interface_count,
2436                                                       100000))
2437                         wpa_supplicant_req_scan(wpa_s, interface_count,
2438                                                 100000);
2439                 interface_count++;
2440         } else
2441                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2442
2443         return 0;
2444 }
2445
2446
2447 static int wpa_supplicant_daemon(const char *pid_file)
2448 {
2449         wpa_printf(MSG_DEBUG, "Daemonize..");
2450         return os_daemonize(pid_file);
2451 }
2452
2453
2454 static struct wpa_supplicant * wpa_supplicant_alloc(void)
2455 {
2456         struct wpa_supplicant *wpa_s;
2457
2458         wpa_s = os_zalloc(sizeof(*wpa_s));
2459         if (wpa_s == NULL)
2460                 return NULL;
2461         wpa_s->scan_req = INITIAL_SCAN_REQ;
2462         wpa_s->scan_interval = 5;
2463         wpa_s->new_connection = 1;
2464         wpa_s->parent = wpa_s;
2465         wpa_s->sched_scanning = 0;
2466
2467         return wpa_s;
2468 }
2469
2470
2471 #ifdef CONFIG_HT_OVERRIDES
2472
2473 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2474                              struct ieee80211_ht_capabilities *htcaps,
2475                              struct ieee80211_ht_capabilities *htcaps_mask,
2476                              const char *ht_mcs)
2477 {
2478         /* parse ht_mcs into hex array */
2479         int i;
2480         const char *tmp = ht_mcs;
2481         char *end = NULL;
2482
2483         /* If ht_mcs is null, do not set anything */
2484         if (!ht_mcs)
2485                 return 0;
2486
2487         /* This is what we are setting in the kernel */
2488         os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
2489
2490         wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2491
2492         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2493                 errno = 0;
2494                 long v = strtol(tmp, &end, 16);
2495                 if (errno == 0) {
2496                         wpa_msg(wpa_s, MSG_DEBUG,
2497                                 "htcap value[%i]: %ld end: %p  tmp: %p",
2498                                 i, v, end, tmp);
2499                         if (end == tmp)
2500                                 break;
2501
2502                         htcaps->supported_mcs_set[i] = v;
2503                         tmp = end;
2504                 } else {
2505                         wpa_msg(wpa_s, MSG_ERROR,
2506                                 "Failed to parse ht-mcs: %s, error: %s\n",
2507                                 ht_mcs, strerror(errno));
2508                         return -1;
2509                 }
2510         }
2511
2512         /*
2513          * If we were able to parse any values, then set mask for the MCS set.
2514          */
2515         if (i) {
2516                 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
2517                           IEEE80211_HT_MCS_MASK_LEN - 1);
2518                 /* skip the 3 reserved bits */
2519                 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
2520                         0x1f;
2521         }
2522
2523         return 0;
2524 }
2525
2526
2527 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2528                                  struct ieee80211_ht_capabilities *htcaps,
2529                                  struct ieee80211_ht_capabilities *htcaps_mask,
2530                                  int disabled)
2531 {
2532         u16 msk;
2533
2534         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2535
2536         if (disabled == -1)
2537                 return 0;
2538
2539         msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
2540         htcaps_mask->ht_capabilities_info |= msk;
2541         if (disabled)
2542                 htcaps->ht_capabilities_info &= msk;
2543         else
2544                 htcaps->ht_capabilities_info |= msk;
2545
2546         return 0;
2547 }
2548
2549
2550 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2551                                 struct ieee80211_ht_capabilities *htcaps,
2552                                 struct ieee80211_ht_capabilities *htcaps_mask,
2553                                 int factor)
2554 {
2555         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2556
2557         if (factor == -1)
2558                 return 0;
2559
2560         if (factor < 0 || factor > 3) {
2561                 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2562                         "Must be 0-3 or -1", factor);
2563                 return -EINVAL;
2564         }
2565
2566         htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
2567         htcaps->a_mpdu_params &= ~0x3;
2568         htcaps->a_mpdu_params |= factor & 0x3;
2569
2570         return 0;
2571 }
2572
2573
2574 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
2575                                  struct ieee80211_ht_capabilities *htcaps,
2576                                  struct ieee80211_ht_capabilities *htcaps_mask,
2577                                  int density)
2578 {
2579         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
2580
2581         if (density == -1)
2582                 return 0;
2583
2584         if (density < 0 || density > 7) {
2585                 wpa_msg(wpa_s, MSG_ERROR,
2586                         "ampdu_density: %d out of range. Must be 0-7 or -1.",
2587                         density);
2588                 return -EINVAL;
2589         }
2590
2591         htcaps_mask->a_mpdu_params |= 0x1C;
2592         htcaps->a_mpdu_params &= ~(0x1C);
2593         htcaps->a_mpdu_params |= (density << 2) & 0x1C;
2594
2595         return 0;
2596 }
2597
2598
2599 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
2600                                 struct ieee80211_ht_capabilities *htcaps,
2601                                 struct ieee80211_ht_capabilities *htcaps_mask,
2602                                 int disabled)
2603 {
2604         /* Masking these out disables HT40 */
2605         u16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
2606                                HT_CAP_INFO_SHORT_GI40MHZ);
2607
2608         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
2609
2610         if (disabled)
2611                 htcaps->ht_capabilities_info &= ~msk;
2612         else
2613                 htcaps->ht_capabilities_info |= msk;
2614
2615         htcaps_mask->ht_capabilities_info |= msk;
2616
2617         return 0;
2618 }
2619
2620
2621 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
2622                                struct ieee80211_ht_capabilities *htcaps,
2623                                struct ieee80211_ht_capabilities *htcaps_mask,
2624                                int disabled)
2625 {
2626         /* Masking these out disables SGI */
2627         u16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
2628                                HT_CAP_INFO_SHORT_GI40MHZ);
2629
2630         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
2631
2632         if (disabled)
2633                 htcaps->ht_capabilities_info &= ~msk;
2634         else
2635                 htcaps->ht_capabilities_info |= msk;
2636
2637         htcaps_mask->ht_capabilities_info |= msk;
2638
2639         return 0;
2640 }
2641
2642
2643 void wpa_supplicant_apply_ht_overrides(
2644         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2645         struct wpa_driver_associate_params *params)
2646 {
2647         struct ieee80211_ht_capabilities *htcaps;
2648         struct ieee80211_ht_capabilities *htcaps_mask;
2649
2650         if (!ssid)
2651                 return;
2652
2653         params->disable_ht = ssid->disable_ht;
2654         if (!params->htcaps || !params->htcaps_mask)
2655                 return;
2656
2657         htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
2658         htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
2659         wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
2660         wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
2661                               ssid->disable_max_amsdu);
2662         wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
2663         wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
2664         wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
2665         wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
2666 }
2667
2668 #endif /* CONFIG_HT_OVERRIDES */
2669
2670
2671 #ifdef CONFIG_VHT_OVERRIDES
2672 void wpa_supplicant_apply_vht_overrides(
2673         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2674         struct wpa_driver_associate_params *params)
2675 {
2676         struct ieee80211_vht_capabilities *vhtcaps;
2677         struct ieee80211_vht_capabilities *vhtcaps_mask;
2678
2679         if (!ssid)
2680                 return;
2681
2682         params->disable_vht = ssid->disable_vht;
2683
2684         vhtcaps = (void *) params->vhtcaps;
2685         vhtcaps_mask = (void *) params->vhtcaps_mask;
2686
2687         if (!vhtcaps || !vhtcaps_mask)
2688                 return;
2689
2690         vhtcaps->vht_capabilities_info = ssid->vht_capa;
2691         vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
2692
2693 #define OVERRIDE_MCS(i)                                                 \
2694         if (ssid->vht_tx_mcs_nss_ ##i >= 0) {                           \
2695                 vhtcaps_mask->vht_supported_mcs_set.tx_map |=           \
2696                         3 << 2 * (i - 1);                               \
2697                 vhtcaps->vht_supported_mcs_set.tx_map |=                \
2698                         ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1);       \
2699         }                                                               \
2700         if (ssid->vht_rx_mcs_nss_ ##i >= 0) {                           \
2701                 vhtcaps_mask->vht_supported_mcs_set.rx_map |=           \
2702                         3 << 2 * (i - 1);                               \
2703                 vhtcaps->vht_supported_mcs_set.rx_map |=                \
2704                         ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1);       \
2705         }
2706
2707         OVERRIDE_MCS(1);
2708         OVERRIDE_MCS(2);
2709         OVERRIDE_MCS(3);
2710         OVERRIDE_MCS(4);
2711         OVERRIDE_MCS(5);
2712         OVERRIDE_MCS(6);
2713         OVERRIDE_MCS(7);
2714         OVERRIDE_MCS(8);
2715 }
2716 #endif /* CONFIG_VHT_OVERRIDES */
2717
2718
2719 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
2720 {
2721 #ifdef PCSC_FUNCS
2722         size_t len;
2723
2724         if (!wpa_s->conf->pcsc_reader)
2725                 return 0;
2726
2727         wpa_s->scard = scard_init(SCARD_TRY_BOTH, wpa_s->conf->pcsc_reader);
2728         if (!wpa_s->scard)
2729                 return 1;
2730
2731         if (wpa_s->conf->pcsc_pin &&
2732             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
2733                 scard_deinit(wpa_s->scard);
2734                 wpa_s->scard = NULL;
2735                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
2736                 return -1;
2737         }
2738
2739         len = sizeof(wpa_s->imsi) - 1;
2740         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
2741                 scard_deinit(wpa_s->scard);
2742                 wpa_s->scard = NULL;
2743                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
2744                 return -1;
2745         }
2746         wpa_s->imsi[len] = '\0';
2747
2748         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
2749
2750         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
2751                    wpa_s->imsi, wpa_s->mnc_len);
2752
2753         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
2754         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
2755 #endif /* PCSC_FUNCS */
2756
2757         return 0;
2758 }
2759
2760
2761 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
2762 {
2763         char *val, *pos;
2764
2765         ext_password_deinit(wpa_s->ext_pw);
2766         wpa_s->ext_pw = NULL;
2767         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
2768
2769         if (!wpa_s->conf->ext_password_backend)
2770                 return 0;
2771
2772         val = os_strdup(wpa_s->conf->ext_password_backend);
2773         if (val == NULL)
2774                 return -1;
2775         pos = os_strchr(val, ':');
2776         if (pos)
2777                 *pos++ = '\0';
2778
2779         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
2780
2781         wpa_s->ext_pw = ext_password_init(val, pos);
2782         os_free(val);
2783         if (wpa_s->ext_pw == NULL) {
2784                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
2785                 return -1;
2786         }
2787         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
2788
2789         return 0;
2790 }
2791
2792
2793 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2794                                      struct wpa_interface *iface)
2795 {
2796         const char *ifname, *driver;
2797         struct wpa_driver_capa capa;
2798
2799         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
2800                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
2801                    iface->confname ? iface->confname : "N/A",
2802                    iface->driver ? iface->driver : "default",
2803                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
2804                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
2805
2806         if (iface->confname) {
2807 #ifdef CONFIG_BACKEND_FILE
2808                 wpa_s->confname = os_rel2abs_path(iface->confname);
2809                 if (wpa_s->confname == NULL) {
2810                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
2811                                    "for configuration file '%s'.",
2812                                    iface->confname);
2813                         return -1;
2814                 }
2815                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
2816                            iface->confname, wpa_s->confname);
2817 #else /* CONFIG_BACKEND_FILE */
2818                 wpa_s->confname = os_strdup(iface->confname);
2819 #endif /* CONFIG_BACKEND_FILE */
2820                 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
2821                 if (wpa_s->conf == NULL) {
2822                         wpa_printf(MSG_ERROR, "Failed to read or parse "
2823                                    "configuration '%s'.", wpa_s->confname);
2824                         return -1;
2825                 }
2826                 wpa_s->confanother = os_rel2abs_path(iface->confanother);
2827                 wpa_config_read(wpa_s->confanother, wpa_s->conf);
2828
2829                 /*
2830                  * Override ctrl_interface and driver_param if set on command
2831                  * line.
2832                  */
2833                 if (iface->ctrl_interface) {
2834                         os_free(wpa_s->conf->ctrl_interface);
2835                         wpa_s->conf->ctrl_interface =
2836                                 os_strdup(iface->ctrl_interface);
2837                 }
2838
2839                 if (iface->driver_param) {
2840                         os_free(wpa_s->conf->driver_param);
2841                         wpa_s->conf->driver_param =
2842                                 os_strdup(iface->driver_param);
2843                 }
2844
2845                 if (iface->p2p_mgmt && !iface->ctrl_interface) {
2846                         os_free(wpa_s->conf->ctrl_interface);
2847                         wpa_s->conf->ctrl_interface = NULL;
2848                 }
2849         } else
2850                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
2851                                                      iface->driver_param);
2852
2853         if (wpa_s->conf == NULL) {
2854                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
2855                 return -1;
2856         }
2857
2858         if (iface->ifname == NULL) {
2859                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
2860                 return -1;
2861         }
2862         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
2863                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
2864                            iface->ifname);
2865                 return -1;
2866         }
2867         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
2868
2869         if (iface->bridge_ifname) {
2870                 if (os_strlen(iface->bridge_ifname) >=
2871                     sizeof(wpa_s->bridge_ifname)) {
2872                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
2873                                    "name '%s'.", iface->bridge_ifname);
2874                         return -1;
2875                 }
2876                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
2877                            sizeof(wpa_s->bridge_ifname));
2878         }
2879
2880         /* RSNA Supplicant Key Management - INITIALIZE */
2881         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
2882         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
2883
2884         /* Initialize driver interface and register driver event handler before
2885          * L2 receive handler so that association events are processed before
2886          * EAPOL-Key packets if both become available for the same select()
2887          * call. */
2888         driver = iface->driver;
2889 next_driver:
2890         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2891                 return -1;
2892
2893         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2894         if (wpa_s->drv_priv == NULL) {
2895                 const char *pos;
2896                 pos = driver ? os_strchr(driver, ',') : NULL;
2897                 if (pos) {
2898                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2899                                 "driver interface - try next driver wrapper");
2900                         driver = pos + 1;
2901                         goto next_driver;
2902                 }
2903                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2904                         "interface");
2905                 return -1;
2906         }
2907         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2908                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2909                         "driver_param '%s'", wpa_s->conf->driver_param);
2910                 return -1;
2911         }
2912
2913         ifname = wpa_drv_get_ifname(wpa_s);
2914         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2915                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2916                         "interface name with '%s'", ifname);
2917                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2918         }
2919
2920         if (wpa_supplicant_init_wpa(wpa_s) < 0)
2921                 return -1;
2922
2923         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2924                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2925                           NULL);
2926         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2927
2928         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2929             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2930                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2931                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2932                         "dot11RSNAConfigPMKLifetime");
2933                 return -1;
2934         }
2935
2936         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2937             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2938                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2939                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2940                         "dot11RSNAConfigPMKReauthThreshold");
2941                 return -1;
2942         }
2943
2944         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2945             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2946                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
2947                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2948                         "dot11RSNAConfigSATimeout");
2949                 return -1;
2950         }
2951
2952         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
2953                                                       &wpa_s->hw.num_modes,
2954                                                       &wpa_s->hw.flags);
2955
2956         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2957                 wpa_s->drv_capa_known = 1;
2958                 wpa_s->drv_flags = capa.flags;
2959                 wpa_s->drv_enc = capa.enc;
2960                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
2961                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2962                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
2963                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
2964                 wpa_s->max_match_sets = capa.max_match_sets;
2965                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2966                 wpa_s->max_stations = capa.max_stations;
2967                 wpa_s->extended_capa = capa.extended_capa;
2968                 wpa_s->extended_capa_mask = capa.extended_capa_mask;
2969                 wpa_s->extended_capa_len = capa.extended_capa_len;
2970                 wpa_s->num_multichan_concurrent =
2971                         capa.num_multichan_concurrent;
2972         }
2973         if (wpa_s->max_remain_on_chan == 0)
2974                 wpa_s->max_remain_on_chan = 1000;
2975
2976         /*
2977          * Only take p2p_mgmt parameters when P2P Device is supported.
2978          * Doing it here as it determines whether l2_packet_init() will be done
2979          * during wpa_supplicant_driver_init().
2980          */
2981         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
2982                 wpa_s->p2p_mgmt = iface->p2p_mgmt;
2983         else
2984                 iface->p2p_mgmt = 1;
2985
2986         if (wpa_s->num_multichan_concurrent == 0)
2987                 wpa_s->num_multichan_concurrent = 1;
2988
2989         if (wpa_supplicant_driver_init(wpa_s) < 0)
2990                 return -1;
2991
2992 #ifdef CONFIG_TDLS
2993         if ((!iface->p2p_mgmt ||
2994              !(wpa_s->drv_flags &
2995                WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
2996             wpa_tdls_init(wpa_s->wpa))
2997                 return -1;
2998 #endif /* CONFIG_TDLS */
2999
3000         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3001             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3002                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3003                 return -1;
3004         }
3005
3006         if (wpas_wps_init(wpa_s))
3007                 return -1;
3008
3009         if (wpa_supplicant_init_eapol(wpa_s) < 0)
3010                 return -1;
3011         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3012
3013         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3014         if (wpa_s->ctrl_iface == NULL) {
3015                 wpa_printf(MSG_ERROR,
3016                            "Failed to initialize control interface '%s'.\n"
3017                            "You may have another wpa_supplicant process "
3018                            "already running or the file was\n"
3019                            "left by an unclean termination of wpa_supplicant "
3020                            "in which case you will need\n"
3021                            "to manually remove this file before starting "
3022                            "wpa_supplicant again.\n",
3023                            wpa_s->conf->ctrl_interface);
3024                 return -1;
3025         }
3026
3027         wpa_s->gas = gas_query_init(wpa_s);
3028         if (wpa_s->gas == NULL) {
3029                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
3030                 return -1;
3031         }
3032
3033 #ifdef CONFIG_P2P
3034         if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
3035                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3036                 return -1;
3037         }
3038 #endif /* CONFIG_P2P */
3039
3040         if (wpa_bss_init(wpa_s) < 0)
3041                 return -1;
3042
3043 #ifdef CONFIG_EAP_PROXY
3044 {
3045         size_t len;
3046         wpa_s->mnc_len = eap_proxy_get_imsi(wpa_s->imsi, &len);
3047         if (wpa_s->mnc_len > 0) {
3048                 wpa_s->imsi[len] = '\0';
3049                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
3050                            wpa_s->imsi, wpa_s->mnc_len);
3051         } else {
3052                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
3053         }
3054 }
3055 #endif /* CONFIG_EAP_PROXY */
3056
3057         if (pcsc_reader_init(wpa_s) < 0)
3058                 return -1;
3059
3060         if (wpas_init_ext_pw(wpa_s) < 0)
3061                 return -1;
3062
3063         return 0;
3064 }
3065
3066
3067 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
3068                                         int notify, int terminate)
3069 {
3070         wpa_s->disconnected = 1;
3071         if (wpa_s->drv_priv) {
3072                 wpa_supplicant_deauthenticate(wpa_s,
3073                                               WLAN_REASON_DEAUTH_LEAVING);
3074
3075                 wpa_drv_set_countermeasures(wpa_s, 0);
3076                 wpa_clear_keys(wpa_s, NULL);
3077         }
3078
3079         wpa_supplicant_cleanup(wpa_s);
3080
3081 #ifdef CONFIG_P2P
3082         if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
3083                 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
3084                         "the management interface is being removed");
3085                 wpas_p2p_deinit_global(wpa_s->global);
3086         }
3087 #endif /* CONFIG_P2P */
3088
3089         if (wpa_s->drv_priv)
3090                 wpa_drv_deinit(wpa_s);
3091
3092         if (notify)
3093                 wpas_notify_iface_removed(wpa_s);
3094
3095         if (terminate)
3096                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3097
3098         if (wpa_s->ctrl_iface) {
3099                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3100                 wpa_s->ctrl_iface = NULL;
3101         }
3102
3103         if (wpa_s->conf != NULL) {
3104                 wpa_config_free(wpa_s->conf);
3105                 wpa_s->conf = NULL;
3106         }
3107
3108         os_free(wpa_s);
3109 }
3110
3111
3112 /**
3113  * wpa_supplicant_add_iface - Add a new network interface
3114  * @global: Pointer to global data from wpa_supplicant_init()
3115  * @iface: Interface configuration options
3116  * Returns: Pointer to the created interface or %NULL on failure
3117  *
3118  * This function is used to add new network interfaces for %wpa_supplicant.
3119  * This can be called before wpa_supplicant_run() to add interfaces before the
3120  * main event loop has been started. In addition, new interfaces can be added
3121  * dynamically while %wpa_supplicant is already running. This could happen,
3122  * e.g., when a hotplug network adapter is inserted.
3123  */
3124 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
3125                                                  struct wpa_interface *iface)
3126 {
3127         struct wpa_supplicant *wpa_s;
3128         struct wpa_interface t_iface;
3129         struct wpa_ssid *ssid;
3130
3131         if (global == NULL || iface == NULL)
3132                 return NULL;
3133
3134         wpa_s = wpa_supplicant_alloc();
3135         if (wpa_s == NULL)
3136                 return NULL;
3137
3138         wpa_s->global = global;
3139
3140         t_iface = *iface;
3141         if (global->params.override_driver) {
3142                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
3143                            "('%s' -> '%s')",
3144                            iface->driver, global->params.override_driver);
3145                 t_iface.driver = global->params.override_driver;
3146         }
3147         if (global->params.override_ctrl_interface) {
3148                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
3149                            "ctrl_interface ('%s' -> '%s')",
3150                            iface->ctrl_interface,
3151                            global->params.override_ctrl_interface);
3152                 t_iface.ctrl_interface =
3153                         global->params.override_ctrl_interface;
3154         }
3155         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3156                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
3157                            iface->ifname);
3158                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
3159                 return NULL;
3160         }
3161
3162         /* Notify the control interfaces about new iface */
3163         if (wpas_notify_iface_added(wpa_s)) {
3164                 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3165                 return NULL;
3166         }
3167
3168         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3169                 wpas_notify_network_added(wpa_s, ssid);
3170
3171         wpa_s->next = global->ifaces;
3172         global->ifaces = wpa_s;
3173
3174         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
3175         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3176
3177         return wpa_s;
3178 }
3179
3180
3181 /**
3182  * wpa_supplicant_remove_iface - Remove a network interface
3183  * @global: Pointer to global data from wpa_supplicant_init()
3184  * @wpa_s: Pointer to the network interface to be removed
3185  * Returns: 0 if interface was removed, -1 if interface was not found
3186  *
3187  * This function can be used to dynamically remove network interfaces from
3188  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
3189  * addition, this function is used to remove all remaining interfaces when
3190  * %wpa_supplicant is terminated.
3191  */
3192 int wpa_supplicant_remove_iface(struct wpa_global *global,
3193                                 struct wpa_supplicant *wpa_s,
3194                                 int terminate)
3195 {
3196         struct wpa_supplicant *prev;
3197
3198         /* Remove interface from the global list of interfaces */
3199         prev = global->ifaces;
3200         if (prev == wpa_s) {
3201                 global->ifaces = wpa_s->next;
3202         } else {
3203                 while (prev && prev->next != wpa_s)
3204                         prev = prev->next;
3205                 if (prev == NULL)
3206                         return -1;
3207                 prev->next = wpa_s->next;
3208         }
3209
3210         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3211
3212         if (global->p2p_group_formation == wpa_s)
3213                 global->p2p_group_formation = NULL;
3214         if (global->p2p_invite_group == wpa_s)
3215                 global->p2p_invite_group = NULL;
3216         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3217
3218         return 0;
3219 }
3220
3221
3222 /**
3223  * wpa_supplicant_get_eap_mode - Get the current EAP mode
3224  * @wpa_s: Pointer to the network interface
3225  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
3226  */
3227 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3228 {
3229         const char *eapol_method;
3230
3231         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3232             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3233                 return "NO-EAP";
3234         }
3235
3236         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3237         if (eapol_method == NULL)
3238                 return "UNKNOWN-EAP";
3239
3240         return eapol_method;
3241 }
3242
3243
3244 /**
3245  * wpa_supplicant_get_iface - Get a new network interface
3246  * @global: Pointer to global data from wpa_supplicant_init()
3247  * @ifname: Interface name
3248  * Returns: Pointer to the interface or %NULL if not found
3249  */
3250 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
3251                                                  const char *ifname)
3252 {
3253         struct wpa_supplicant *wpa_s;
3254
3255         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3256                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3257                         return wpa_s;
3258         }
3259         return NULL;
3260 }
3261
3262
3263 #ifndef CONFIG_NO_WPA_MSG
3264 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
3265 {
3266         struct wpa_supplicant *wpa_s = ctx;
3267         if (wpa_s == NULL)
3268                 return NULL;
3269         return wpa_s->ifname;
3270 }
3271 #endif /* CONFIG_NO_WPA_MSG */
3272
3273
3274 /**
3275  * wpa_supplicant_init - Initialize %wpa_supplicant
3276  * @params: Parameters for %wpa_supplicant
3277  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
3278  *
3279  * This function is used to initialize %wpa_supplicant. After successful
3280  * initialization, the returned data pointer can be used to add and remove
3281  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
3282  */
3283 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
3284 {
3285         struct wpa_global *global;
3286         int ret, i;
3287
3288         if (params == NULL)
3289                 return NULL;
3290
3291 #ifdef CONFIG_DRIVER_NDIS
3292         {
3293                 void driver_ndis_init_ops(void);
3294                 driver_ndis_init_ops();
3295         }
3296 #endif /* CONFIG_DRIVER_NDIS */
3297
3298 #ifndef CONFIG_NO_WPA_MSG
3299         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
3300 #endif /* CONFIG_NO_WPA_MSG */
3301
3302         wpa_debug_open_file(params->wpa_debug_file_path);
3303         if (params->wpa_debug_syslog)
3304                 wpa_debug_open_syslog();
3305         if (params->wpa_debug_tracing) {
3306                 ret = wpa_debug_open_linux_tracing();
3307                 if (ret) {
3308                         wpa_printf(MSG_ERROR,
3309                                    "Failed to enable trace logging");
3310                         return NULL;
3311                 }
3312         }
3313
3314         ret = eap_register_methods();
3315         if (ret) {
3316                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
3317                 if (ret == -2)
3318                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
3319                                    "the same EAP type.");
3320                 return NULL;
3321         }
3322
3323         global = os_zalloc(sizeof(*global));
3324         if (global == NULL)
3325                 return NULL;
3326         dl_list_init(&global->p2p_srv_bonjour);
3327         dl_list_init(&global->p2p_srv_upnp);
3328         global->params.daemonize = params->daemonize;
3329         global->params.wait_for_monitor = params->wait_for_monitor;
3330         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
3331         if (params->pid_file)
3332                 global->params.pid_file = os_strdup(params->pid_file);
3333         if (params->ctrl_interface)
3334                 global->params.ctrl_interface =
3335                         os_strdup(params->ctrl_interface);
3336         if (params->ctrl_interface_group)
3337                 global->params.ctrl_interface_group =
3338                         os_strdup(params->ctrl_interface_group);
3339         if (params->override_driver)
3340                 global->params.override_driver =
3341                         os_strdup(params->override_driver);
3342         if (params->override_ctrl_interface)
3343                 global->params.override_ctrl_interface =
3344                         os_strdup(params->override_ctrl_interface);
3345         wpa_debug_level = global->params.wpa_debug_level =
3346                 params->wpa_debug_level;
3347         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
3348                 params->wpa_debug_show_keys;
3349         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
3350                 params->wpa_debug_timestamp;
3351
3352         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
3353
3354         if (eloop_init()) {
3355                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
3356                 wpa_supplicant_deinit(global);
3357                 return NULL;
3358         }
3359
3360         random_init(params->entropy_file);
3361
3362         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
3363         if (global->ctrl_iface == NULL) {
3364                 wpa_supplicant_deinit(global);
3365                 return NULL;
3366         }
3367
3368         if (wpas_notify_supplicant_initialized(global)) {
3369                 wpa_supplicant_deinit(global);
3370                 return NULL;
3371         }
3372
3373         for (i = 0; wpa_drivers[i]; i++)
3374                 global->drv_count++;
3375         if (global->drv_count == 0) {
3376                 wpa_printf(MSG_ERROR, "No drivers enabled");
3377                 wpa_supplicant_deinit(global);
3378                 return NULL;
3379         }
3380         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
3381         if (global->drv_priv == NULL) {
3382                 wpa_supplicant_deinit(global);
3383                 return NULL;
3384         }
3385
3386 #ifdef CONFIG_WIFI_DISPLAY
3387         if (wifi_display_init(global) < 0) {
3388                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
3389                 wpa_supplicant_deinit(global);
3390                 return NULL;
3391         }
3392 #endif /* CONFIG_WIFI_DISPLAY */
3393
3394         return global;
3395 }
3396
3397
3398 /**
3399  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
3400  * @global: Pointer to global data from wpa_supplicant_init()
3401  * Returns: 0 after successful event loop run, -1 on failure
3402  *
3403  * This function starts the main event loop and continues running as long as
3404  * there are any remaining events. In most cases, this function is running as
3405  * long as the %wpa_supplicant process in still in use.
3406  */
3407 int wpa_supplicant_run(struct wpa_global *global)
3408 {
3409         struct wpa_supplicant *wpa_s;
3410
3411         if (global->params.daemonize &&
3412             wpa_supplicant_daemon(global->params.pid_file))
3413                 return -1;
3414
3415         if (global->params.wait_for_monitor) {
3416                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
3417                         if (wpa_s->ctrl_iface)
3418                                 wpa_supplicant_ctrl_iface_wait(
3419                                         wpa_s->ctrl_iface);
3420         }
3421
3422         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
3423         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
3424
3425         eloop_run();
3426
3427         return 0;
3428 }
3429
3430
3431 /**
3432  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
3433  * @global: Pointer to global data from wpa_supplicant_init()
3434  *
3435  * This function is called to deinitialize %wpa_supplicant and to free all
3436  * allocated resources. Remaining network interfaces will also be removed.
3437  */
3438 void wpa_supplicant_deinit(struct wpa_global *global)
3439 {
3440         int i;
3441
3442         if (global == NULL)
3443                 return;
3444
3445 #ifdef CONFIG_WIFI_DISPLAY
3446         wifi_display_deinit(global);
3447 #endif /* CONFIG_WIFI_DISPLAY */
3448
3449         while (global->ifaces)
3450                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
3451
3452         if (global->ctrl_iface)
3453                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
3454
3455         wpas_notify_supplicant_deinitialized(global);
3456
3457         eap_peer_unregister_methods();
3458 #ifdef CONFIG_AP
3459         eap_server_unregister_methods();
3460 #endif /* CONFIG_AP */
3461
3462         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
3463                 if (!global->drv_priv[i])
3464                         continue;
3465                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
3466         }
3467         os_free(global->drv_priv);
3468
3469         random_deinit();
3470
3471         eloop_destroy();
3472
3473         if (global->params.pid_file) {
3474                 os_daemonize_terminate(global->params.pid_file);
3475                 os_free(global->params.pid_file);
3476         }
3477         os_free(global->params.ctrl_interface);
3478         os_free(global->params.ctrl_interface_group);
3479         os_free(global->params.override_driver);
3480         os_free(global->params.override_ctrl_interface);
3481
3482         os_free(global->p2p_disallow_freq);
3483         os_free(global->add_psk);
3484
3485         os_free(global);
3486         wpa_debug_close_syslog();
3487         wpa_debug_close_file();
3488         wpa_debug_close_linux_tracing();
3489 }
3490
3491
3492 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
3493 {
3494         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
3495             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3496                 char country[3];
3497                 country[0] = wpa_s->conf->country[0];
3498                 country[1] = wpa_s->conf->country[1];
3499                 country[2] = '\0';
3500                 if (wpa_drv_set_country(wpa_s, country) < 0) {
3501                         wpa_printf(MSG_ERROR, "Failed to set country code "
3502                                    "'%s'", country);
3503                 }
3504         }
3505
3506         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
3507                 wpas_init_ext_pw(wpa_s);
3508
3509 #ifdef CONFIG_WPS
3510         wpas_wps_update_config(wpa_s);
3511 #endif /* CONFIG_WPS */
3512
3513 #ifdef CONFIG_P2P
3514         wpas_p2p_update_config(wpa_s);
3515 #endif /* CONFIG_P2P */
3516
3517         wpa_s->conf->changed_parameters = 0;
3518 }
3519
3520
3521 static void add_freq(int *freqs, int *num_freqs, int freq)
3522 {
3523         int i;
3524
3525         for (i = 0; i < *num_freqs; i++) {
3526                 if (freqs[i] == freq)
3527                         return;
3528         }
3529
3530         freqs[*num_freqs] = freq;
3531         (*num_freqs)++;
3532 }
3533
3534
3535 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
3536 {
3537         struct wpa_bss *bss, *cbss;
3538         const int max_freqs = 10;
3539         int *freqs;
3540         int num_freqs = 0;
3541
3542         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
3543         if (freqs == NULL)
3544                 return NULL;
3545
3546         cbss = wpa_s->current_bss;
3547
3548         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
3549                 if (bss == cbss)
3550                         continue;
3551                 if (bss->ssid_len == cbss->ssid_len &&
3552                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
3553                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
3554                         add_freq(freqs, &num_freqs, bss->freq);
3555                         if (num_freqs == max_freqs)
3556                                 break;
3557                 }
3558         }
3559
3560         if (num_freqs == 0) {
3561                 os_free(freqs);
3562                 freqs = NULL;
3563         }
3564
3565         return freqs;
3566 }
3567
3568
3569 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
3570 {
3571         int timeout;
3572         int count;
3573         int *freqs = NULL;
3574
3575         /*
3576          * Remove possible authentication timeout since the connection failed.
3577          */
3578         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3579
3580         if (wpa_s->disconnected) {
3581                 /*
3582                  * There is no point in blacklisting the AP if this event is
3583                  * generated based on local request to disconnect.
3584                  */
3585                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
3586                         "indication since interface has been put into "
3587                         "disconnected state");
3588                 return;
3589         }
3590
3591         /*
3592          * Add the failed BSSID into the blacklist and speed up next scan
3593          * attempt if there could be other APs that could accept association.
3594          * The current blacklist count indicates how many times we have tried
3595          * connecting to this AP and multiple attempts mean that other APs are
3596          * either not available or has already been tried, so that we can start
3597          * increasing the delay here to avoid constant scanning.
3598          */
3599         count = wpa_blacklist_add(wpa_s, bssid);
3600         if (count == 1 && wpa_s->current_bss) {
3601                 /*
3602                  * This BSS was not in the blacklist before. If there is
3603                  * another BSS available for the same ESS, we should try that
3604                  * next. Otherwise, we may as well try this one once more
3605                  * before allowing other, likely worse, ESSes to be considered.
3606                  */
3607                 freqs = get_bss_freqs_in_ess(wpa_s);
3608                 if (freqs) {
3609                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
3610                                 "has been seen; try it next");
3611                         wpa_blacklist_add(wpa_s, bssid);
3612                         /*
3613                          * On the next scan, go through only the known channels
3614                          * used in this ESS based on previous scans to speed up
3615                          * common load balancing use case.
3616                          */
3617                         os_free(wpa_s->next_scan_freqs);
3618                         wpa_s->next_scan_freqs = freqs;
3619                 }
3620         }
3621
3622         /*
3623          * Add previous failure count in case the temporary blacklist was
3624          * cleared due to no other BSSes being available.
3625          */
3626         count += wpa_s->extra_blacklist_count;
3627
3628         if (count > 3 && wpa_s->current_ssid) {
3629                 wpa_printf(MSG_DEBUG, "Continuous association failures - "
3630                            "consider temporary network disabling");
3631                 wpas_auth_failed(wpa_s);
3632         }
3633
3634         switch (count) {
3635         case 1:
3636                 timeout = 100;
3637                 break;
3638         case 2:
3639                 timeout = 500;
3640                 break;
3641         case 3:
3642                 timeout = 1000;
3643                 break;
3644         case 4:
3645                 timeout = 5000;
3646                 break;
3647         default:
3648                 timeout = 10000;
3649                 break;
3650         }
3651
3652         wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
3653                 "ms", count, timeout);
3654
3655         /*
3656          * TODO: if more than one possible AP is available in scan results,
3657          * could try the other ones before requesting a new scan.
3658          */
3659         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
3660                                 1000 * (timeout % 1000));
3661
3662         wpas_p2p_continue_after_scan(wpa_s);
3663 }
3664
3665
3666 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
3667 {
3668         return wpa_s->conf->ap_scan == 2 ||
3669                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
3670 }
3671
3672
3673 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
3674 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
3675                                               struct wpa_ssid *ssid,
3676                                               const char *field,
3677                                               const char *value)
3678 {
3679 #ifdef IEEE8021X_EAPOL
3680         struct eap_peer_config *eap = &ssid->eap;
3681
3682         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
3683         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
3684                               (const u8 *) value, os_strlen(value));
3685
3686         switch (wpa_supplicant_ctrl_req_from_string(field)) {
3687         case WPA_CTRL_REQ_EAP_IDENTITY:
3688                 os_free(eap->identity);
3689                 eap->identity = (u8 *) os_strdup(value);
3690                 eap->identity_len = os_strlen(value);
3691                 eap->pending_req_identity = 0;
3692                 if (ssid == wpa_s->current_ssid)
3693                         wpa_s->reassociate = 1;
3694                 break;
3695         case WPA_CTRL_REQ_EAP_PASSWORD:
3696                 os_free(eap->password);
3697                 eap->password = (u8 *) os_strdup(value);
3698                 eap->password_len = os_strlen(value);
3699                 eap->pending_req_password = 0;
3700                 if (ssid == wpa_s->current_ssid)
3701                         wpa_s->reassociate = 1;
3702                 break;
3703         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
3704                 os_free(eap->new_password);
3705                 eap->new_password = (u8 *) os_strdup(value);
3706                 eap->new_password_len = os_strlen(value);
3707                 eap->pending_req_new_password = 0;
3708                 if (ssid == wpa_s->current_ssid)
3709                         wpa_s->reassociate = 1;
3710                 break;
3711         case WPA_CTRL_REQ_EAP_PIN:
3712                 os_free(eap->pin);
3713                 eap->pin = os_strdup(value);
3714                 eap->pending_req_pin = 0;
3715                 if (ssid == wpa_s->current_ssid)
3716                         wpa_s->reassociate = 1;
3717                 break;
3718         case WPA_CTRL_REQ_EAP_OTP:
3719                 os_free(eap->otp);
3720                 eap->otp = (u8 *) os_strdup(value);
3721                 eap->otp_len = os_strlen(value);
3722                 os_free(eap->pending_req_otp);
3723                 eap->pending_req_otp = NULL;
3724                 eap->pending_req_otp_len = 0;
3725                 break;
3726         case WPA_CTRL_REQ_EAP_PASSPHRASE:
3727                 os_free(eap->private_key_passwd);
3728                 eap->private_key_passwd = (u8 *) os_strdup(value);
3729                 eap->pending_req_passphrase = 0;
3730                 if (ssid == wpa_s->current_ssid)
3731                         wpa_s->reassociate = 1;
3732                 break;
3733         default:
3734                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
3735                 return -1;
3736         }
3737
3738         return 0;
3739 #else /* IEEE8021X_EAPOL */
3740         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
3741         return -1;
3742 #endif /* IEEE8021X_EAPOL */
3743 }
3744 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
3745
3746
3747 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
3748 {
3749         int i;
3750         unsigned int drv_enc;
3751
3752         if (ssid == NULL)
3753                 return 1;
3754
3755         if (ssid->disabled)
3756                 return 1;
3757
3758         if (wpa_s && wpa_s->drv_capa_known)
3759                 drv_enc = wpa_s->drv_enc;
3760         else
3761                 drv_enc = (unsigned int) -1;
3762
3763         for (i = 0; i < NUM_WEP_KEYS; i++) {
3764                 size_t len = ssid->wep_key_len[i];
3765                 if (len == 0)
3766                         continue;
3767                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
3768                         continue;
3769                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
3770                         continue;
3771                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
3772                         continue;
3773                 return 1; /* invalid WEP key */
3774         }
3775
3776         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
3777             !ssid->ext_psk)
3778                 return 1;
3779
3780         return 0;
3781 }
3782
3783
3784 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
3785 {
3786         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
3787                 return 1;
3788         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
3789                 return 0;
3790         return -1;
3791 }
3792
3793
3794 void wpas_auth_failed(struct wpa_supplicant *wpa_s)
3795 {
3796         struct wpa_ssid *ssid = wpa_s->current_ssid;
3797         int dur;
3798         struct os_time now;
3799
3800         if (ssid == NULL) {
3801                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
3802                            "SSID block");
3803                 return;
3804         }
3805
3806         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
3807                 return;
3808
3809         ssid->auth_failures++;
3810
3811 #ifdef CONFIG_P2P
3812         if (ssid->p2p_group &&
3813             (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
3814                 /*
3815                  * Skip the wait time since there is a short timeout on the
3816                  * connection to a P2P group.
3817                  */
3818                 return;
3819         }
3820 #endif /* CONFIG_P2P */
3821
3822         if (ssid->auth_failures > 50)
3823                 dur = 300;
3824         else if (ssid->auth_failures > 20)
3825                 dur = 120;
3826         else if (ssid->auth_failures > 10)
3827                 dur = 60;
3828         else if (ssid->auth_failures > 5)
3829                 dur = 30;
3830         else if (ssid->auth_failures > 1)
3831                 dur = 20;
3832         else
3833                 dur = 10;
3834
3835         os_get_time(&now);
3836         if (now.sec + dur <= ssid->disabled_until.sec)
3837                 return;
3838
3839         ssid->disabled_until.sec = now.sec + dur;
3840
3841         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
3842                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d",
3843                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
3844                 ssid->auth_failures, dur);
3845 }
3846
3847
3848 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
3849                               struct wpa_ssid *ssid, int clear_failures)
3850 {
3851         if (ssid == NULL)
3852                 return;
3853
3854         if (ssid->disabled_until.sec) {
3855                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
3856                         "id=%d ssid=\"%s\"",
3857                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
3858         }
3859         ssid->disabled_until.sec = 0;
3860         ssid->disabled_until.usec = 0;
3861         if (clear_failures)
3862                 ssid->auth_failures = 0;
3863 }
3864
3865
3866 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
3867 {
3868         size_t i;
3869
3870         if (wpa_s->disallow_aps_bssid == NULL)
3871                 return 0;
3872
3873         for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
3874                 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
3875                               bssid, ETH_ALEN) == 0)
3876                         return 1;
3877         }
3878
3879         return 0;
3880 }
3881
3882
3883 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
3884                     size_t ssid_len)
3885 {
3886         size_t i;
3887
3888         if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
3889                 return 0;
3890
3891         for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
3892                 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
3893                 if (ssid_len == s->ssid_len &&
3894                     os_memcmp(ssid, s->ssid, ssid_len) == 0)
3895                         return 1;
3896         }
3897
3898         return 0;
3899 }
3900
3901
3902 /**
3903  * wpas_request_connection - Request a new connection
3904  * @wpa_s: Pointer to the network interface
3905  *
3906  * This function is used to request a new connection to be found. It will mark
3907  * the interface to allow reassociation and request a new scan to find a
3908  * suitable network to connect to.
3909  */
3910 void wpas_request_connection(struct wpa_supplicant *wpa_s)
3911 {
3912         wpa_s->normal_scans = 0;
3913         wpa_supplicant_reinit_autoscan(wpa_s);
3914         wpa_s->extra_blacklist_count = 0;
3915         wpa_s->disconnected = 0;
3916         wpa_s->reassociate = 1;
3917
3918         if (wpa_supplicant_fast_associate(wpa_s) != 1)
3919                 wpa_supplicant_req_scan(wpa_s, 0, 0);
3920 }
3921
3922
3923 /**
3924  * wpas_wpa_is_in_progress - Check whether a connection is in progress
3925  * @wpa_s: Pointer to wpa_supplicant data
3926  *
3927  * This function is to check if the wpa state is in beginning of the connection
3928  * during 4-way handshake or group key handshake with WPA on any shared
3929  * interface.
3930  */
3931 int wpas_wpa_is_in_progress(struct wpa_supplicant *wpa_s)
3932 {
3933         const char *rn, *rn2;
3934         struct wpa_supplicant *ifs;
3935
3936         if (!wpa_s->driver->get_radio_name)
3937                 return 0;
3938
3939         rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
3940         if (rn == NULL || rn[0] == '\0')
3941                 return 0;
3942
3943         for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
3944                 if (ifs == wpa_s || !ifs->driver->get_radio_name)
3945                         continue;
3946
3947                 rn2 = ifs->driver->get_radio_name(ifs->drv_priv);
3948                 if (!rn2 || os_strcmp(rn, rn2) != 0)
3949                         continue;
3950                 if (ifs->wpa_state >= WPA_AUTHENTICATING &&
3951                     ifs->wpa_state != WPA_COMPLETED) {
3952                         wpa_dbg(wpa_s, MSG_DEBUG, "Connection is in progress "
3953                                 "on interface %s - defer scan", ifs->ifname);
3954                         return 1;
3955                 }
3956         }
3957
3958         return 0;
3959 }
3960
3961
3962 /*
3963  * Find the operating frequencies of any of the virtual interfaces that
3964  * are using the same radio as the current interface.
3965  */
3966 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
3967                            int *freq_array, unsigned int len)
3968 {
3969         const char *rn, *rn2;
3970         struct wpa_supplicant *ifs;
3971         u8 bssid[ETH_ALEN];
3972         int freq;
3973         unsigned int idx = 0, i;
3974
3975         os_memset(freq_array, 0, sizeof(int) * len);
3976
3977         /* First add the frequency of the local interface */
3978         if (wpa_s->current_ssid != NULL && wpa_s->assoc_freq != 0) {
3979                 if (wpa_s->current_ssid->mode == WPAS_MODE_AP ||
3980                     wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)
3981                         freq_array[idx++] = wpa_s->current_ssid->frequency;
3982                 else if (wpa_drv_get_bssid(wpa_s, bssid) == 0)
3983                         freq_array[idx++] = wpa_s->assoc_freq;
3984         }
3985
3986         /* If get_radio_name is not supported, use only the local freq */
3987         if (!wpa_s->driver->get_radio_name) {
3988                 freq = wpa_drv_shared_freq(wpa_s);
3989                 if (freq > 0 && idx < len &&
3990                     (idx == 0 || freq_array[0] != freq))
3991                         freq_array[idx++] = freq;
3992                 return idx;
3993         }
3994
3995         rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
3996         if (rn == NULL || rn[0] == '\0')
3997                 return idx;
3998
3999         for (ifs = wpa_s->global->ifaces, idx = 0; ifs && idx < len;
4000              ifs = ifs->next) {
4001                 if (wpa_s == ifs || !ifs->driver->get_radio_name)
4002                         continue;
4003
4004                 rn2 = ifs->driver->get_radio_name(ifs->drv_priv);
4005                 if (!rn2 || os_strcmp(rn, rn2) != 0)
4006                         continue;
4007
4008                 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
4009                         continue;
4010
4011                 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
4012                     ifs->current_ssid->mode == WPAS_MODE_P2P_GO)
4013                         freq = ifs->current_ssid->frequency;
4014                 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
4015                         freq = ifs->assoc_freq;
4016                 else
4017                         continue;
4018
4019                 /* Hold only distinct freqs */
4020                 for (i = 0; i < idx; i++)
4021                         if (freq_array[i] == freq)
4022                                 break;
4023
4024                 if (i == idx)
4025                         freq_array[idx++] = freq;
4026         }
4027         return idx;
4028 }