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