wpa_supplicant/wpa_supplicant.c

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