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 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 659                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 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                                             wpa_s->current_ssid,
1356                                             try_opportunistic) == 0)
1357                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1358                 wpa_ie_len = sizeof(wpa_ie);
1359                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1360                                               wpa_ie, &wpa_ie_len)) {
1361                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1362                                 "key management and encryption suites");
1363                         return;
1364                 }
1365         } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
1366                    wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
1367                 /*
1368                  * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1369                  * use non-WPA since the scan results did not indicate that the
1370                  * AP is using WPA or WPA2.
1371                  */
1372                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1373                 wpa_ie_len = 0;
1374                 wpa_s->wpa_proto = 0;
1375         } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
1376                 wpa_ie_len = sizeof(wpa_ie);
1377                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1378                                               wpa_ie, &wpa_ie_len)) {
1379                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1380                                 "key management and encryption suites (no "
1381                                 "scan results)");
1382                         return;
1383                 }
1384 #ifdef CONFIG_WPS
1385         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1386                 struct wpabuf *wps_ie;
1387                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1388                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1389                         wpa_ie_len = wpabuf_len(wps_ie);
1390                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1391                 } else
1392                         wpa_ie_len = 0;
1393                 wpabuf_free(wps_ie);
1394                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1395                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1396                         params.wps = WPS_MODE_PRIVACY;
1397                 else
1398                         params.wps = WPS_MODE_OPEN;
1399                 wpa_s->wpa_proto = 0;
1400 #endif /* CONFIG_WPS */
1401         } else {
1402                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1403                 wpa_ie_len = 0;
1404                 wpa_s->wpa_proto = 0;
1405         }
1406
1407 #ifdef CONFIG_P2P
1408         if (wpa_s->global->p2p) {
1409                 u8 *pos;
1410                 size_t len;
1411                 int res;
1412                 pos = wpa_ie + wpa_ie_len;
1413                 len = sizeof(wpa_ie) - wpa_ie_len;
1414                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1415                                             ssid->p2p_group);
1416                 if (res >= 0)
1417                         wpa_ie_len += res;
1418         }
1419
1420         wpa_s->cross_connect_disallowed = 0;
1421         if (bss) {
1422                 struct wpabuf *p2p;
1423                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1424                 if (p2p) {
1425                         wpa_s->cross_connect_disallowed =
1426                                 p2p_get_cross_connect_disallowed(p2p);
1427                         wpabuf_free(p2p);
1428                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1429                                 "connection",
1430                                 wpa_s->cross_connect_disallowed ?
1431                                 "disallows" : "allows");
1432                 }
1433         }
1434 #endif /* CONFIG_P2P */
1435
1436 #ifdef CONFIG_HS20
1437         if (wpa_s->conf->hs20) {
1438                 struct wpabuf *hs20;
1439                 hs20 = wpabuf_alloc(20);
1440                 if (hs20) {
1441                         wpas_hs20_add_indication(hs20);
1442                         os_memcpy(wpa_ie + wpa_ie_len, wpabuf_head(hs20),
1443                                   wpabuf_len(hs20));
1444                         wpa_ie_len += wpabuf_len(hs20);
1445                         wpabuf_free(hs20);
1446                 }
1447         }
1448 #endif /* CONFIG_HS20 */
1449
1450         ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab);
1451         if (ext_capab_len > 0) {
1452                 u8 *pos = wpa_ie;
1453                 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
1454                         pos += 2 + pos[1];
1455                 os_memmove(pos + ext_capab_len, pos,
1456                            wpa_ie_len - (pos - wpa_ie));
1457                 wpa_ie_len += ext_capab_len;
1458                 os_memcpy(pos, ext_capab, ext_capab_len);
1459         }
1460
1461         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1462         use_crypt = 1;
1463         cipher_pairwise = wpa_cipher_to_suite_driver(wpa_s->pairwise_cipher);
1464         cipher_group = wpa_cipher_to_suite_driver(wpa_s->group_cipher);
1465         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1466             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1467                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1468                         use_crypt = 0;
1469                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1470                         use_crypt = 1;
1471                         wep_keys_set = 1;
1472                 }
1473         }
1474         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1475                 use_crypt = 0;
1476
1477 #ifdef IEEE8021X_EAPOL
1478         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1479                 if ((ssid->eapol_flags &
1480                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1481                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1482                     !wep_keys_set) {
1483                         use_crypt = 0;
1484                 } else {
1485                         /* Assume that dynamic WEP-104 keys will be used and
1486                          * set cipher suites in order for drivers to expect
1487                          * encryption. */
1488                         cipher_pairwise = cipher_group = CIPHER_WEP104;
1489                 }
1490         }
1491 #endif /* IEEE8021X_EAPOL */
1492
1493         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1494                 /* Set the key before (and later after) association */
1495                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1496         }
1497
1498         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1499         if (bss) {
1500                 params.ssid = bss->ssid;
1501                 params.ssid_len = bss->ssid_len;
1502                 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1503                         wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
1504                                    MACSTR " freq=%u MHz based on scan results "
1505                                    "(bssid_set=%d)",
1506                                    MAC2STR(bss->bssid), bss->freq,
1507                                    ssid->bssid_set);
1508                         params.bssid = bss->bssid;
1509                         params.freq = bss->freq;
1510                 }
1511         } else {
1512                 params.ssid = ssid->ssid;
1513                 params.ssid_len = ssid->ssid_len;
1514         }
1515
1516         if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
1517             wpa_s->conf->ap_scan == 2) {
1518                 params.bssid = ssid->bssid;
1519                 params.fixed_bssid = 1;
1520         }
1521
1522         if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1523             params.freq == 0)
1524                 params.freq = ssid->frequency; /* Initial channel for IBSS */
1525         params.wpa_ie = wpa_ie;
1526         params.wpa_ie_len = wpa_ie_len;
1527         params.pairwise_suite = cipher_pairwise;
1528         params.group_suite = cipher_group;
1529         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1530         params.wpa_proto = wpa_s->wpa_proto;
1531         params.auth_alg = algs;
1532         params.mode = ssid->mode;
1533         params.bg_scan_period = ssid->bg_scan_period;
1534         for (i = 0; i < NUM_WEP_KEYS; i++) {
1535                 if (ssid->wep_key_len[i])
1536                         params.wep_key[i] = ssid->wep_key[i];
1537                 params.wep_key_len[i] = ssid->wep_key_len[i];
1538         }
1539         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1540
1541         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1542             (params.key_mgmt_suite == KEY_MGMT_PSK ||
1543              params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1544                 params.passphrase = ssid->passphrase;
1545                 if (ssid->psk_set)
1546                         params.psk = ssid->psk;
1547         }
1548
1549         params.drop_unencrypted = use_crypt;
1550
1551 #ifdef CONFIG_IEEE80211W
1552         params.mgmt_frame_protection =
1553                 ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1554                 wpa_s->conf->pmf : ssid->ieee80211w;
1555         if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
1556                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1557                 struct wpa_ie_data ie;
1558                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1559                     ie.capabilities &
1560                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1561                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1562                                 "MFP: require MFP");
1563                         params.mgmt_frame_protection =
1564                                 MGMT_FRAME_PROTECTION_REQUIRED;
1565                 }
1566         }
1567 #endif /* CONFIG_IEEE80211W */
1568
1569         params.p2p = ssid->p2p_group;
1570
1571         if (wpa_s->parent->set_sta_uapsd)
1572                 params.uapsd = wpa_s->parent->sta_uapsd;
1573         else
1574                 params.uapsd = -1;
1575
1576 #ifdef CONFIG_HT_OVERRIDES
1577         os_memset(&htcaps, 0, sizeof(htcaps));
1578         os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
1579         params.htcaps = (u8 *) &htcaps;
1580         params.htcaps_mask = (u8 *) &htcaps_mask;
1581         wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
1582 #endif /* CONFIG_HT_OVERRIDES */
1583
1584         ret = wpa_drv_associate(wpa_s, &params);
1585         if (ret < 0) {
1586                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1587                         "failed");
1588                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1589                         /*
1590                          * The driver is known to mean what is saying, so we
1591                          * can stop right here; the association will not
1592                          * succeed.
1593                          */
1594                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1595                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1596                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1597                         return;
1598                 }
1599                 /* try to continue anyway; new association will be tried again
1600                  * after timeout */
1601                 assoc_failed = 1;
1602         }
1603
1604         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1605                 /* Set the key after the association just in case association
1606                  * cleared the previously configured key. */
1607                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1608                 /* No need to timeout authentication since there is no key
1609                  * management. */
1610                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1611                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1612 #ifdef CONFIG_IBSS_RSN
1613         } else if (ssid->mode == WPAS_MODE_IBSS &&
1614                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1615                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1616                 /*
1617                  * RSN IBSS authentication is per-STA and we can disable the
1618                  * per-BSSID authentication.
1619                  */
1620                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1621 #endif /* CONFIG_IBSS_RSN */
1622         } else {
1623                 /* Timeout for IEEE 802.11 authentication and association */
1624                 int timeout = 60;
1625
1626                 if (assoc_failed) {
1627                         /* give IBSS a bit more time */
1628                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1629                 } else if (wpa_s->conf->ap_scan == 1) {
1630                         /* give IBSS a bit more time */
1631                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1632                 }
1633                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1634         }
1635
1636         if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1637             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1638                 /* Set static WEP keys again */
1639                 wpa_set_wep_keys(wpa_s, ssid);
1640         }
1641
1642         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1643                 /*
1644                  * Do not allow EAP session resumption between different
1645                  * network configurations.
1646                  */
1647                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1648         }
1649         old_ssid = wpa_s->current_ssid;
1650         wpa_s->current_ssid = ssid;
1651         wpa_s->current_bss = bss;
1652         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1653         wpa_supplicant_initiate_eapol(wpa_s);
1654         if (old_ssid != wpa_s->current_ssid)
1655                 wpas_notify_network_changed(wpa_s);
1656 }
1657
1658
1659 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1660                                             const u8 *addr)
1661 {
1662         struct wpa_ssid *old_ssid;
1663
1664         wpa_clear_keys(wpa_s, addr);
1665         old_ssid = wpa_s->current_ssid;
1666         wpa_supplicant_mark_disassoc(wpa_s);
1667         wpa_sm_set_config(wpa_s->wpa, NULL);
1668         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1669         if (old_ssid != wpa_s->current_ssid)
1670                 wpas_notify_network_changed(wpa_s);
1671         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1672 }
1673
1674
1675 /**
1676  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1677  * @wpa_s: Pointer to wpa_supplicant data
1678  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1679  *
1680  * This function is used to request %wpa_supplicant to deauthenticate from the
1681  * current AP.
1682  */
1683 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1684                                    int reason_code)
1685 {
1686         u8 *addr = NULL;
1687         union wpa_event_data event;
1688         int zero_addr = 0;
1689
1690         wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
1691                 " pending_bssid=" MACSTR " reason=%d state=%s",
1692                 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
1693                 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
1694
1695         if (!is_zero_ether_addr(wpa_s->bssid))
1696                 addr = wpa_s->bssid;
1697         else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
1698                  (wpa_s->wpa_state == WPA_AUTHENTICATING ||
1699                   wpa_s->wpa_state == WPA_ASSOCIATING))
1700                 addr = wpa_s->pending_bssid;
1701         else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
1702                 /*
1703                  * When using driver-based BSS selection, we may not know the
1704                  * BSSID with which we are currently trying to associate. We
1705                  * need to notify the driver of this disconnection even in such
1706                  * a case, so use the all zeros address here.
1707                  */
1708                 addr = wpa_s->bssid;
1709                 zero_addr = 1;
1710         }
1711
1712 #ifdef CONFIG_TDLS
1713         wpa_tdls_teardown_peers(wpa_s->wpa);
1714 #endif /* CONFIG_TDLS */
1715
1716         if (addr) {
1717                 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
1718                 os_memset(&event, 0, sizeof(event));
1719                 event.deauth_info.reason_code = (u16) reason_code;
1720                 event.deauth_info.locally_generated = 1;
1721                 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
1722                 if (zero_addr)
1723                         addr = NULL;
1724         }
1725
1726         wpa_supplicant_clear_connection(wpa_s, addr);
1727 }
1728
1729 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
1730                                               struct wpa_ssid *ssid)
1731 {
1732         if (!ssid || !ssid->disabled || ssid->disabled == 2)
1733                 return;
1734
1735         ssid->disabled = 0;
1736         wpas_clear_temp_disabled(wpa_s, ssid, 1);
1737         wpas_notify_network_enabled_changed(wpa_s, ssid);
1738
1739         /*
1740          * Try to reassociate since there is no current configuration and a new
1741          * network was made available.
1742          */
1743         if (!wpa_s->current_ssid)
1744                 wpa_s->reassociate = 1;
1745 }
1746
1747
1748 /**
1749  * wpa_supplicant_enable_network - Mark a configured network as enabled
1750  * @wpa_s: wpa_supplicant structure for a network interface
1751  * @ssid: wpa_ssid structure for a configured network or %NULL
1752  *
1753  * Enables the specified network or all networks if no network specified.
1754  */
1755 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1756                                    struct wpa_ssid *ssid)
1757 {
1758         if (ssid == NULL) {
1759                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
1760                         wpa_supplicant_enable_one_network(wpa_s, ssid);
1761         } else
1762                 wpa_supplicant_enable_one_network(wpa_s, ssid);
1763
1764         if (wpa_s->reassociate) {
1765                 if (wpa_s->sched_scanning) {
1766                         wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
1767                                    "new network to scan filters");
1768                         wpa_supplicant_cancel_sched_scan(wpa_s);
1769                 }
1770
1771                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1772         }
1773 }
1774
1775
1776 /**
1777  * wpa_supplicant_disable_network - Mark a configured network as disabled
1778  * @wpa_s: wpa_supplicant structure for a network interface
1779  * @ssid: wpa_ssid structure for a configured network or %NULL
1780  *
1781  * Disables the specified network or all networks if no network specified.
1782  */
1783 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1784                                     struct wpa_ssid *ssid)
1785 {
1786         struct wpa_ssid *other_ssid;
1787         int was_disabled;
1788
1789         if (ssid == NULL) {
1790                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1791                      other_ssid = other_ssid->next) {
1792                         was_disabled = other_ssid->disabled;
1793                         if (was_disabled == 2)
1794                                 continue; /* do not change persistent P2P group
1795                                            * data */
1796
1797                         other_ssid->disabled = 1;
1798
1799                         if (was_disabled != other_ssid->disabled)
1800                                 wpas_notify_network_enabled_changed(
1801                                         wpa_s, other_ssid);
1802                 }
1803                 if (wpa_s->current_ssid)
1804                         wpa_supplicant_deauthenticate(
1805                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1806         } else if (ssid->disabled != 2) {
1807                 if (ssid == wpa_s->current_ssid)
1808                         wpa_supplicant_deauthenticate(
1809                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1810
1811                 was_disabled = ssid->disabled;
1812
1813                 ssid->disabled = 1;
1814
1815                 if (was_disabled != ssid->disabled)
1816                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1817         }
1818 }
1819
1820
1821 /**
1822  * wpa_supplicant_select_network - Attempt association with a network
1823  * @wpa_s: wpa_supplicant structure for a network interface
1824  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1825  */
1826 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1827                                    struct wpa_ssid *ssid)
1828 {
1829
1830         struct wpa_ssid *other_ssid;
1831         int disconnected = 0;
1832
1833         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
1834                 wpa_supplicant_deauthenticate(
1835                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1836                 disconnected = 1;
1837         }
1838
1839         if (ssid)
1840                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1841
1842         /*
1843          * Mark all other networks disabled or mark all networks enabled if no
1844          * network specified.
1845          */
1846         for (other_ssid = wpa_s->conf->ssid; other_ssid;
1847              other_ssid = other_ssid->next) {
1848                 int was_disabled = other_ssid->disabled;
1849                 if (was_disabled == 2)
1850                         continue; /* do not change persistent P2P group data */
1851
1852                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
1853                 if (was_disabled && !other_ssid->disabled)
1854                         wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
1855
1856                 if (was_disabled != other_ssid->disabled)
1857                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1858         }
1859
1860         if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
1861                 /* We are already associated with the selected network */
1862                 wpa_printf(MSG_DEBUG, "Already associated with the "
1863                            "selected network - do nothing");
1864                 return;
1865         }
1866
1867         if (ssid)
1868                 wpa_s->current_ssid = ssid;
1869         wpa_s->connect_without_scan = NULL;
1870         wpa_s->disconnected = 0;
1871         wpa_s->reassociate = 1;
1872
1873         if (wpa_supplicant_fast_associate(wpa_s) != 1)
1874                 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
1875
1876         if (ssid)
1877                 wpas_notify_network_selected(wpa_s, ssid);
1878 }
1879
1880
1881 /**
1882  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1883  * @wpa_s: wpa_supplicant structure for a network interface
1884  * @ap_scan: AP scan mode
1885  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1886  *
1887  */
1888 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1889 {
1890
1891         int old_ap_scan;
1892
1893         if (ap_scan < 0 || ap_scan > 2)
1894                 return -1;
1895
1896 #ifdef ANDROID
1897         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
1898             wpa_s->wpa_state >= WPA_ASSOCIATING &&
1899             wpa_s->wpa_state < WPA_COMPLETED) {
1900                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
1901                            "associating", wpa_s->conf->ap_scan, ap_scan);
1902                 return 0;
1903         }
1904 #endif /* ANDROID */
1905
1906         old_ap_scan = wpa_s->conf->ap_scan;
1907         wpa_s->conf->ap_scan = ap_scan;
1908
1909         if (old_ap_scan != wpa_s->conf->ap_scan)
1910                 wpas_notify_ap_scan_changed(wpa_s);
1911
1912         return 0;
1913 }
1914
1915
1916 /**
1917  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
1918  * @wpa_s: wpa_supplicant structure for a network interface
1919  * @expire_age: Expiration age in seconds
1920  * Returns: 0 if succeed or -1 if expire_age has an invalid value
1921  *
1922  */
1923 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
1924                                           unsigned int bss_expire_age)
1925 {
1926         if (bss_expire_age < 10) {
1927                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
1928                         bss_expire_age);
1929                 return -1;
1930         }
1931         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
1932                 bss_expire_age);
1933         wpa_s->conf->bss_expiration_age = bss_expire_age;
1934
1935         return 0;
1936 }
1937
1938
1939 /**
1940  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
1941  * @wpa_s: wpa_supplicant structure for a network interface
1942  * @expire_count: number of scans after which an unseen BSS is reclaimed
1943  * Returns: 0 if succeed or -1 if expire_count has an invalid value
1944  *
1945  */
1946 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
1947                                             unsigned int bss_expire_count)
1948 {
1949         if (bss_expire_count < 1) {
1950                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
1951                         bss_expire_count);
1952                 return -1;
1953         }
1954         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
1955                 bss_expire_count);
1956         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
1957
1958         return 0;
1959 }
1960
1961
1962 /**
1963  * wpa_supplicant_set_scan_interval - Set scan interval
1964  * @wpa_s: wpa_supplicant structure for a network interface
1965  * @scan_interval: scan interval in seconds
1966  * Returns: 0 if succeed or -1 if scan_interval has an invalid value
1967  *
1968  */
1969 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
1970                                      int scan_interval)
1971 {
1972         if (scan_interval < 0) {
1973                 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
1974                         scan_interval);
1975                 return -1;
1976         }
1977         wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
1978                 scan_interval);
1979         wpa_supplicant_update_scan_int(wpa_s, scan_interval);
1980
1981         return 0;
1982 }
1983
1984
1985 /**
1986  * wpa_supplicant_set_debug_params - Set global debug params
1987  * @global: wpa_global structure
1988  * @debug_level: debug level
1989  * @debug_timestamp: determines if show timestamp in debug data
1990  * @debug_show_keys: determines if show keys in debug data
1991  * Returns: 0 if succeed or -1 if debug_level has wrong value
1992  */
1993 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
1994                                     int debug_timestamp, int debug_show_keys)
1995 {
1996
1997         int old_level, old_timestamp, old_show_keys;
1998
1999         /* check for allowed debuglevels */
2000         if (debug_level != MSG_EXCESSIVE &&
2001             debug_level != MSG_MSGDUMP &&
2002             debug_level != MSG_DEBUG &&
2003             debug_level != MSG_INFO &&
2004             debug_level != MSG_WARNING &&
2005             debug_level != MSG_ERROR)
2006                 return -1;
2007
2008         old_level = wpa_debug_level;
2009         old_timestamp = wpa_debug_timestamp;
2010         old_show_keys = wpa_debug_show_keys;
2011
2012         wpa_debug_level = debug_level;
2013         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2014         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2015
2016         if (wpa_debug_level != old_level)
2017                 wpas_notify_debug_level_changed(global);
2018         if (wpa_debug_timestamp != old_timestamp)
2019                 wpas_notify_debug_timestamp_changed(global);
2020         if (wpa_debug_show_keys != old_show_keys)
2021                 wpas_notify_debug_show_keys_changed(global);
2022
2023         return 0;
2024 }
2025
2026
2027 /**
2028  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2029  * @wpa_s: Pointer to wpa_supplicant data
2030  * Returns: A pointer to the current network structure or %NULL on failure
2031  */
2032 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2033 {
2034         struct wpa_ssid *entry;
2035         u8 ssid[MAX_SSID_LEN];
2036         int res;
2037         size_t ssid_len;
2038         u8 bssid[ETH_ALEN];
2039         int wired;
2040
2041         res = wpa_drv_get_ssid(wpa_s, ssid);
2042         if (res < 0) {
2043                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2044                         "driver");
2045                 return NULL;
2046         }
2047         ssid_len = res;
2048
2049         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2050                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2051                         "driver");
2052                 return NULL;
2053         }
2054
2055         wired = wpa_s->conf->ap_scan == 0 &&
2056                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2057
2058         entry = wpa_s->conf->ssid;
2059         while (entry) {
2060                 if (!wpas_network_disabled(wpa_s, entry) &&
2061                     ((ssid_len == entry->ssid_len &&
2062                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2063                     (!entry->bssid_set ||
2064                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2065                         return entry;
2066 #ifdef CONFIG_WPS
2067                 if (!wpas_network_disabled(wpa_s, entry) &&
2068                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2069                     (entry->ssid == NULL || entry->ssid_len == 0) &&
2070                     (!entry->bssid_set ||
2071                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2072                         return entry;
2073 #endif /* CONFIG_WPS */
2074
2075                 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2076                     entry->ssid_len == 0 &&
2077                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2078                         return entry;
2079
2080                 entry = entry->next;
2081         }
2082
2083         return NULL;
2084 }
2085
2086
2087 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2088 {
2089         struct wpa_global *global = wpa_s->global;
2090
2091         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2092                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2093                 if (global->drv_priv[i] == NULL) {
2094                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2095                                    "'%s'", wpa_drivers[i]->name);
2096                         return -1;
2097                 }
2098         }
2099
2100         wpa_s->driver = wpa_drivers[i];
2101         wpa_s->global_drv_priv = global->drv_priv[i];
2102
2103         return 0;
2104 }
2105
2106
2107 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2108                                      const char *name)
2109 {
2110         int i;
2111         size_t len;
2112         const char *pos, *driver = name;
2113
2114         if (wpa_s == NULL)
2115                 return -1;
2116
2117         if (wpa_drivers[0] == NULL) {
2118                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2119                         "wpa_supplicant");
2120                 return -1;
2121         }
2122
2123         if (name == NULL) {
2124                 /* default to first driver in the list */
2125                 return select_driver(wpa_s, 0);
2126         }
2127
2128         do {
2129                 pos = os_strchr(driver, ',');
2130                 if (pos)
2131                         len = pos - driver;
2132                 else
2133                         len = os_strlen(driver);
2134
2135                 for (i = 0; wpa_drivers[i]; i++) {
2136                         if (os_strlen(wpa_drivers[i]->name) == len &&
2137                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
2138                             0) {
2139                                 /* First driver that succeeds wins */
2140                                 if (select_driver(wpa_s, i) == 0)
2141                                         return 0;
2142                         }
2143                 }
2144
2145                 driver = pos + 1;
2146         } while (pos);
2147
2148         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2149         return -1;
2150 }
2151
2152
2153 /**
2154  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2155  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2156  *      with struct wpa_driver_ops::init()
2157  * @src_addr: Source address of the EAPOL frame
2158  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2159  * @len: Length of the EAPOL data
2160  *
2161  * This function is called for each received EAPOL frame. Most driver
2162  * interfaces rely on more generic OS mechanism for receiving frames through
2163  * l2_packet, but if such a mechanism is not available, the driver wrapper may
2164  * take care of received EAPOL frames and deliver them to the core supplicant
2165  * code by calling this function.
2166  */
2167 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
2168                              const u8 *buf, size_t len)
2169 {
2170         struct wpa_supplicant *wpa_s = ctx;
2171
2172         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2173         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
2174
2175         if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2176             (wpa_s->last_eapol_matches_bssid &&
2177 #ifdef CONFIG_AP
2178              !wpa_s->ap_iface &&
2179 #endif /* CONFIG_AP */
2180              os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
2181                 /*
2182                  * There is possible race condition between receiving the
2183                  * association event and the EAPOL frame since they are coming
2184                  * through different paths from the driver. In order to avoid
2185                  * issues in trying to process the EAPOL frame before receiving
2186                  * association information, lets queue it for processing until
2187                  * the association event is received. This may also be needed in
2188                  * driver-based roaming case, so also use src_addr != BSSID as a
2189                  * trigger if we have previously confirmed that the
2190                  * Authenticator uses BSSID as the src_addr (which is not the
2191                  * case with wired IEEE 802.1X).
2192                  */
2193                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2194                         "of received EAPOL frame (state=%s bssid=" MACSTR ")",
2195                         wpa_supplicant_state_txt(wpa_s->wpa_state),
2196                         MAC2STR(wpa_s->bssid));
2197                 wpabuf_free(wpa_s->pending_eapol_rx);
2198                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2199                 if (wpa_s->pending_eapol_rx) {
2200                         os_get_time(&wpa_s->pending_eapol_rx_time);
2201                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2202                                   ETH_ALEN);
2203                 }
2204                 return;
2205         }
2206
2207         wpa_s->last_eapol_matches_bssid =
2208                 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2209
2210 #ifdef CONFIG_AP
2211         if (wpa_s->ap_iface) {
2212                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2213                 return;
2214         }
2215 #endif /* CONFIG_AP */
2216
2217         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2218                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2219                         "no key management is configured");
2220                 return;
2221         }
2222
2223         if (wpa_s->eapol_received == 0 &&
2224             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2225              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2226              wpa_s->wpa_state != WPA_COMPLETED) &&
2227             (wpa_s->current_ssid == NULL ||
2228              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2229                 /* Timeout for completing IEEE 802.1X and WPA authentication */
2230                 wpa_supplicant_req_auth_timeout(
2231                         wpa_s,
2232                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2233                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2234                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2235                         70 : 10, 0);
2236         }
2237         wpa_s->eapol_received++;
2238
2239         if (wpa_s->countermeasures) {
2240                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2241                         "EAPOL packet");
2242                 return;
2243         }
2244
2245 #ifdef CONFIG_IBSS_RSN
2246         if (wpa_s->current_ssid &&
2247             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2248                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2249                 return;
2250         }
2251 #endif /* CONFIG_IBSS_RSN */
2252
2253         /* Source address of the incoming EAPOL frame could be compared to the
2254          * current BSSID. However, it is possible that a centralized
2255          * Authenticator could be using another MAC address than the BSSID of
2256          * an AP, so just allow any address to be used for now. The replies are
2257          * still sent to the current BSSID (if available), though. */
2258
2259         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2260         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2261             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2262                 return;
2263         wpa_drv_poll(wpa_s);
2264         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2265                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2266         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2267                 /*
2268                  * Set portValid = TRUE here since we are going to skip 4-way
2269                  * handshake processing which would normally set portValid. We
2270                  * need this to allow the EAPOL state machines to be completed
2271                  * without going through EAPOL-Key handshake.
2272                  */
2273                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2274         }
2275 }
2276
2277
2278 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2279 {
2280         if (wpa_s->driver->send_eapol) {
2281                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2282                 if (addr)
2283                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2284         } else if (!(wpa_s->drv_flags &
2285                      WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
2286                 l2_packet_deinit(wpa_s->l2);
2287                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2288                                            wpa_drv_get_mac_addr(wpa_s),
2289                                            ETH_P_EAPOL,
2290                                            wpa_supplicant_rx_eapol, wpa_s, 0);
2291                 if (wpa_s->l2 == NULL)
2292                         return -1;
2293         } else {
2294                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2295                 if (addr)
2296                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2297         }
2298
2299         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2300                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2301                 return -1;
2302         }
2303
2304         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2305                 MAC2STR(wpa_s->own_addr));
2306         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2307
2308         return 0;
2309 }
2310
2311
2312 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
2313                                            const u8 *buf, size_t len)
2314 {
2315         struct wpa_supplicant *wpa_s = ctx;
2316         const struct l2_ethhdr *eth;
2317
2318         if (len < sizeof(*eth))
2319                 return;
2320         eth = (const struct l2_ethhdr *) buf;
2321
2322         if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2323             !(eth->h_dest[0] & 0x01)) {
2324                 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2325                         " (bridge - not for this interface - ignore)",
2326                         MAC2STR(src_addr), MAC2STR(eth->h_dest));
2327                 return;
2328         }
2329
2330         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2331                 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
2332         wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2333                                 len - sizeof(*eth));
2334 }
2335
2336
2337 /**
2338  * wpa_supplicant_driver_init - Initialize driver interface parameters
2339  * @wpa_s: Pointer to wpa_supplicant data
2340  * Returns: 0 on success, -1 on failure
2341  *
2342  * This function is called to initialize driver interface parameters.
2343  * wpa_drv_init() must have been called before this function to initialize the
2344  * driver interface.
2345  */
2346 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2347 {
2348         static int interface_count = 0;
2349
2350         if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2351                 return -1;
2352
2353         if (wpa_s->bridge_ifname[0]) {
2354                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2355                         "interface '%s'", wpa_s->bridge_ifname);
2356                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2357                                               wpa_s->own_addr,
2358                                               ETH_P_EAPOL,
2359                                               wpa_supplicant_rx_eapol_bridge,
2360                                               wpa_s, 1);
2361                 if (wpa_s->l2_br == NULL) {
2362                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2363                                 "connection for the bridge interface '%s'",
2364                                 wpa_s->bridge_ifname);
2365                         return -1;
2366                 }
2367         }
2368
2369         wpa_clear_keys(wpa_s, NULL);
2370
2371         /* Make sure that TKIP countermeasures are not left enabled (could
2372          * happen if wpa_supplicant is killed during countermeasures. */
2373         wpa_drv_set_countermeasures(wpa_s, 0);
2374
2375         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2376         wpa_drv_flush_pmkid(wpa_s);
2377
2378         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2379         wpa_s->prev_scan_wildcard = 0;
2380
2381         if (wpa_supplicant_enabled_networks(wpa_s)) {
2382                 if (wpa_supplicant_delayed_sched_scan(wpa_s, interface_count,
2383                                                       100000))
2384                         wpa_supplicant_req_scan(wpa_s, interface_count,
2385                                                 100000);
2386                 interface_count++;
2387         } else
2388                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2389
2390         return 0;
2391 }
2392
2393
2394 static int wpa_supplicant_daemon(const char *pid_file)
2395 {
2396         wpa_printf(MSG_DEBUG, "Daemonize..");
2397         return os_daemonize(pid_file);
2398 }
2399
2400
2401 static struct wpa_supplicant * wpa_supplicant_alloc(void)
2402 {
2403         struct wpa_supplicant *wpa_s;
2404
2405         wpa_s = os_zalloc(sizeof(*wpa_s));
2406         if (wpa_s == NULL)
2407                 return NULL;
2408         wpa_s->scan_req = INITIAL_SCAN_REQ;
2409         wpa_s->scan_interval = 5;
2410         wpa_s->new_connection = 1;
2411         wpa_s->parent = wpa_s;
2412         wpa_s->sched_scanning = 0;
2413
2414         return wpa_s;
2415 }
2416
2417
2418 #ifdef CONFIG_HT_OVERRIDES
2419
2420 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2421                              struct ieee80211_ht_capabilities *htcaps,
2422                              struct ieee80211_ht_capabilities *htcaps_mask,
2423                              const char *ht_mcs)
2424 {
2425         /* parse ht_mcs into hex array */
2426         int i;
2427         const char *tmp = ht_mcs;
2428         char *end = NULL;
2429
2430         /* If ht_mcs is null, do not set anything */
2431         if (!ht_mcs)
2432                 return 0;
2433
2434         /* This is what we are setting in the kernel */
2435         os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
2436
2437         wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2438
2439         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2440                 errno = 0;
2441                 long v = strtol(tmp, &end, 16);
2442                 if (errno == 0) {
2443                         wpa_msg(wpa_s, MSG_DEBUG,
2444                                 "htcap value[%i]: %ld end: %p  tmp: %p",
2445                                 i, v, end, tmp);
2446                         if (end == tmp)
2447                                 break;
2448
2449                         htcaps->supported_mcs_set[i] = v;
2450                         tmp = end;
2451                 } else {
2452                         wpa_msg(wpa_s, MSG_ERROR,
2453                                 "Failed to parse ht-mcs: %s, error: %s\n",
2454                                 ht_mcs, strerror(errno));
2455                         return -1;
2456                 }
2457         }
2458
2459         /*
2460          * If we were able to parse any values, then set mask for the MCS set.
2461          */
2462         if (i) {
2463                 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
2464                           IEEE80211_HT_MCS_MASK_LEN - 1);
2465                 /* skip the 3 reserved bits */
2466                 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
2467                         0x1f;
2468         }
2469
2470         return 0;
2471 }
2472
2473
2474 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2475                                  struct ieee80211_ht_capabilities *htcaps,
2476                                  struct ieee80211_ht_capabilities *htcaps_mask,
2477                                  int disabled)
2478 {
2479         u16 msk;
2480
2481         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2482
2483         if (disabled == -1)
2484                 return 0;
2485
2486         msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
2487         htcaps_mask->ht_capabilities_info |= msk;
2488         if (disabled)
2489                 htcaps->ht_capabilities_info &= msk;
2490         else
2491                 htcaps->ht_capabilities_info |= msk;
2492
2493         return 0;
2494 }
2495
2496
2497 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2498                                 struct ieee80211_ht_capabilities *htcaps,
2499                                 struct ieee80211_ht_capabilities *htcaps_mask,
2500                                 int factor)
2501 {
2502         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2503
2504         if (factor == -1)
2505                 return 0;
2506
2507         if (factor < 0 || factor > 3) {
2508                 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2509                         "Must be 0-3 or -1", factor);
2510                 return -EINVAL;
2511         }
2512
2513         htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
2514         htcaps->a_mpdu_params &= ~0x3;
2515         htcaps->a_mpdu_params |= factor & 0x3;
2516
2517         return 0;
2518 }
2519
2520
2521 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
2522                                  struct ieee80211_ht_capabilities *htcaps,
2523                                  struct ieee80211_ht_capabilities *htcaps_mask,
2524                                  int density)
2525 {
2526         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
2527
2528         if (density == -1)
2529                 return 0;
2530
2531         if (density < 0 || density > 7) {
2532                 wpa_msg(wpa_s, MSG_ERROR,
2533                         "ampdu_density: %d out of range. Must be 0-7 or -1.",
2534                         density);
2535                 return -EINVAL;
2536         }
2537
2538         htcaps_mask->a_mpdu_params |= 0x1C;
2539         htcaps->a_mpdu_params &= ~(0x1C);
2540         htcaps->a_mpdu_params |= (density << 2) & 0x1C;
2541
2542         return 0;
2543 }
2544
2545
2546 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
2547                                 struct ieee80211_ht_capabilities *htcaps,
2548                                 struct ieee80211_ht_capabilities *htcaps_mask,
2549                                 int disabled)
2550 {
2551         /* Masking these out disables HT40 */
2552         u16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
2553                                HT_CAP_INFO_SHORT_GI40MHZ);
2554
2555         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
2556
2557         if (disabled)
2558                 htcaps->ht_capabilities_info &= ~msk;
2559         else
2560                 htcaps->ht_capabilities_info |= msk;
2561
2562         htcaps_mask->ht_capabilities_info |= msk;
2563
2564         return 0;
2565 }
2566
2567
2568 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
2569                                struct ieee80211_ht_capabilities *htcaps,
2570                                struct ieee80211_ht_capabilities *htcaps_mask,
2571                                int disabled)
2572 {
2573         /* Masking these out disables SGI */
2574         u16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
2575                                HT_CAP_INFO_SHORT_GI40MHZ);
2576
2577         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
2578
2579         if (disabled)
2580                 htcaps->ht_capabilities_info &= ~msk;
2581         else
2582                 htcaps->ht_capabilities_info |= msk;
2583
2584         htcaps_mask->ht_capabilities_info |= msk;
2585
2586         return 0;
2587 }
2588
2589
2590 void wpa_supplicant_apply_ht_overrides(
2591         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2592         struct wpa_driver_associate_params *params)
2593 {
2594         struct ieee80211_ht_capabilities *htcaps;
2595         struct ieee80211_ht_capabilities *htcaps_mask;
2596
2597         if (!ssid)
2598                 return;
2599
2600         params->disable_ht = ssid->disable_ht;
2601         if (!params->htcaps || !params->htcaps_mask)
2602                 return;
2603
2604         htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
2605         htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
2606         wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
2607         wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
2608                               ssid->disable_max_amsdu);
2609         wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
2610         wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
2611         wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
2612         wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
2613 }
2614
2615 #endif /* CONFIG_HT_OVERRIDES */
2616
2617
2618 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
2619 {
2620 #ifdef PCSC_FUNCS
2621         size_t len;
2622
2623         if (!wpa_s->conf->pcsc_reader)
2624                 return 0;
2625
2626         wpa_s->scard = scard_init(SCARD_TRY_BOTH, wpa_s->conf->pcsc_reader);
2627         if (!wpa_s->scard)
2628                 return 1;
2629
2630         if (wpa_s->conf->pcsc_pin &&
2631             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
2632                 scard_deinit(wpa_s->scard);
2633                 wpa_s->scard = NULL;
2634                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
2635                 return -1;
2636         }
2637
2638         len = sizeof(wpa_s->imsi) - 1;
2639         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
2640                 scard_deinit(wpa_s->scard);
2641                 wpa_s->scard = NULL;
2642                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
2643                 return -1;
2644         }
2645         wpa_s->imsi[len] = '\0';
2646
2647         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
2648
2649         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
2650                    wpa_s->imsi, wpa_s->mnc_len);
2651
2652         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
2653         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
2654 #endif /* PCSC_FUNCS */
2655
2656         return 0;
2657 }
2658
2659
2660 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
2661 {
2662         char *val, *pos;
2663
2664         ext_password_deinit(wpa_s->ext_pw);
2665         wpa_s->ext_pw = NULL;
2666         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
2667
2668         if (!wpa_s->conf->ext_password_backend)
2669                 return 0;
2670
2671         val = os_strdup(wpa_s->conf->ext_password_backend);
2672         if (val == NULL)
2673                 return -1;
2674         pos = os_strchr(val, ':');
2675         if (pos)
2676                 *pos++ = '\0';
2677
2678         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
2679
2680         wpa_s->ext_pw = ext_password_init(val, pos);
2681         os_free(val);
2682         if (wpa_s->ext_pw == NULL) {
2683                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
2684                 return -1;
2685         }
2686         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
2687
2688         return 0;
2689 }
2690
2691
2692 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2693                                      struct wpa_interface *iface)
2694 {
2695         const char *ifname, *driver;
2696         struct wpa_driver_capa capa;
2697
2698         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
2699                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
2700                    iface->confname ? iface->confname : "N/A",
2701                    iface->driver ? iface->driver : "default",
2702                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
2703                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
2704
2705         if (iface->confname) {
2706 #ifdef CONFIG_BACKEND_FILE
2707                 wpa_s->confname = os_rel2abs_path(iface->confname);
2708                 if (wpa_s->confname == NULL) {
2709                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
2710                                    "for configuration file '%s'.",
2711                                    iface->confname);
2712                         return -1;
2713                 }
2714                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
2715                            iface->confname, wpa_s->confname);
2716 #else /* CONFIG_BACKEND_FILE */
2717                 wpa_s->confname = os_strdup(iface->confname);
2718 #endif /* CONFIG_BACKEND_FILE */
2719                 wpa_s->conf = wpa_config_read(wpa_s->confname);
2720                 if (wpa_s->conf == NULL) {
2721                         wpa_printf(MSG_ERROR, "Failed to read or parse "
2722                                    "configuration '%s'.", wpa_s->confname);
2723                         return -1;
2724                 }
2725
2726                 /*
2727                  * Override ctrl_interface and driver_param if set on command
2728                  * line.
2729                  */
2730                 if (iface->ctrl_interface) {
2731                         os_free(wpa_s->conf->ctrl_interface);
2732                         wpa_s->conf->ctrl_interface =
2733                                 os_strdup(iface->ctrl_interface);
2734                 }
2735
2736                 if (iface->driver_param) {
2737                         os_free(wpa_s->conf->driver_param);
2738                         wpa_s->conf->driver_param =
2739                                 os_strdup(iface->driver_param);
2740                 }
2741         } else
2742                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
2743                                                      iface->driver_param);
2744
2745         if (wpa_s->conf == NULL) {
2746                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
2747                 return -1;
2748         }
2749
2750         if (iface->ifname == NULL) {
2751                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
2752                 return -1;
2753         }
2754         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
2755                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
2756                            iface->ifname);
2757                 return -1;
2758         }
2759         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
2760
2761         if (iface->bridge_ifname) {
2762                 if (os_strlen(iface->bridge_ifname) >=
2763                     sizeof(wpa_s->bridge_ifname)) {
2764                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
2765                                    "name '%s'.", iface->bridge_ifname);
2766                         return -1;
2767                 }
2768                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
2769                            sizeof(wpa_s->bridge_ifname));
2770         }
2771
2772         /* RSNA Supplicant Key Management - INITIALIZE */
2773         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
2774         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
2775
2776         /* Initialize driver interface and register driver event handler before
2777          * L2 receive handler so that association events are processed before
2778          * EAPOL-Key packets if both become available for the same select()
2779          * call. */
2780         driver = iface->driver;
2781 next_driver:
2782         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2783                 return -1;
2784
2785         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2786         if (wpa_s->drv_priv == NULL) {
2787                 const char *pos;
2788                 pos = driver ? os_strchr(driver, ',') : NULL;
2789                 if (pos) {
2790                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2791                                 "driver interface - try next driver wrapper");
2792                         driver = pos + 1;
2793                         goto next_driver;
2794                 }
2795                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2796                         "interface");
2797                 return -1;
2798         }
2799         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2800                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2801                         "driver_param '%s'", wpa_s->conf->driver_param);
2802                 return -1;
2803         }
2804
2805         ifname = wpa_drv_get_ifname(wpa_s);
2806         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2807                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2808                         "interface name with '%s'", ifname);
2809                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2810         }
2811
2812         if (wpa_supplicant_init_wpa(wpa_s) < 0)
2813                 return -1;
2814
2815         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2816                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2817                           NULL);
2818         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2819
2820         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2821             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2822                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2823                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2824                         "dot11RSNAConfigPMKLifetime");
2825                 return -1;
2826         }
2827
2828         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2829             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2830                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2831                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2832                         "dot11RSNAConfigPMKReauthThreshold");
2833                 return -1;
2834         }
2835
2836         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2837             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2838                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
2839                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2840                         "dot11RSNAConfigSATimeout");
2841                 return -1;
2842         }
2843
2844         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
2845                                                       &wpa_s->hw.num_modes,
2846                                                       &wpa_s->hw.flags);
2847
2848         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2849                 wpa_s->drv_capa_known = 1;
2850                 wpa_s->drv_flags = capa.flags;
2851                 wpa_s->drv_enc = capa.enc;
2852                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
2853                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2854                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
2855                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
2856                 wpa_s->max_match_sets = capa.max_match_sets;
2857                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2858                 wpa_s->max_stations = capa.max_stations;
2859         }
2860         if (wpa_s->max_remain_on_chan == 0)
2861                 wpa_s->max_remain_on_chan = 1000;
2862
2863         if (wpa_supplicant_driver_init(wpa_s) < 0)
2864                 return -1;
2865
2866 #ifdef CONFIG_TDLS
2867         if (wpa_tdls_init(wpa_s->wpa))
2868                 return -1;
2869 #endif /* CONFIG_TDLS */
2870
2871         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
2872             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
2873                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
2874                 return -1;
2875         }
2876
2877         if (wpas_wps_init(wpa_s))
2878                 return -1;
2879
2880         if (wpa_supplicant_init_eapol(wpa_s) < 0)
2881                 return -1;
2882         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2883
2884         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
2885         if (wpa_s->ctrl_iface == NULL) {
2886                 wpa_printf(MSG_ERROR,
2887                            "Failed to initialize control interface '%s'.\n"
2888                            "You may have another wpa_supplicant process "
2889                            "already running or the file was\n"
2890                            "left by an unclean termination of wpa_supplicant "
2891                            "in which case you will need\n"
2892                            "to manually remove this file before starting "
2893                            "wpa_supplicant again.\n",
2894                            wpa_s->conf->ctrl_interface);
2895                 return -1;
2896         }
2897
2898         wpa_s->gas = gas_query_init(wpa_s);
2899         if (wpa_s->gas == NULL) {
2900                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
2901                 return -1;
2902         }
2903
2904 #ifdef CONFIG_P2P
2905         if (wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
2906                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
2907                 return -1;
2908         }
2909 #endif /* CONFIG_P2P */
2910
2911         if (wpa_bss_init(wpa_s) < 0)
2912                 return -1;
2913
2914         if (pcsc_reader_init(wpa_s) < 0)
2915                 return -1;
2916
2917         if (wpas_init_ext_pw(wpa_s) < 0)
2918                 return -1;
2919
2920         return 0;
2921 }
2922
2923
2924 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
2925                                         int notify, int terminate)
2926 {
2927         if (wpa_s->drv_priv) {
2928                 wpa_supplicant_deauthenticate(wpa_s,
2929                                               WLAN_REASON_DEAUTH_LEAVING);
2930
2931                 wpa_drv_set_countermeasures(wpa_s, 0);
2932                 wpa_clear_keys(wpa_s, NULL);
2933         }
2934
2935         wpa_supplicant_cleanup(wpa_s);
2936
2937 #ifdef CONFIG_P2P
2938         if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
2939                 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
2940                         "the management interface is being removed");
2941                 wpas_p2p_deinit_global(wpa_s->global);
2942         }
2943 #endif /* CONFIG_P2P */
2944
2945         if (wpa_s->drv_priv)
2946                 wpa_drv_deinit(wpa_s);
2947
2948         if (notify)
2949                 wpas_notify_iface_removed(wpa_s);
2950
2951         if (terminate)
2952                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
2953
2954         if (wpa_s->ctrl_iface) {
2955                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
2956                 wpa_s->ctrl_iface = NULL;
2957         }
2958
2959         if (wpa_s->conf != NULL) {
2960                 wpa_config_free(wpa_s->conf);
2961                 wpa_s->conf = NULL;
2962         }
2963 }
2964
2965
2966 /**
2967  * wpa_supplicant_add_iface - Add a new network interface
2968  * @global: Pointer to global data from wpa_supplicant_init()
2969  * @iface: Interface configuration options
2970  * Returns: Pointer to the created interface or %NULL on failure
2971  *
2972  * This function is used to add new network interfaces for %wpa_supplicant.
2973  * This can be called before wpa_supplicant_run() to add interfaces before the
2974  * main event loop has been started. In addition, new interfaces can be added
2975  * dynamically while %wpa_supplicant is already running. This could happen,
2976  * e.g., when a hotplug network adapter is inserted.
2977  */
2978 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
2979                                                  struct wpa_interface *iface)
2980 {
2981         struct wpa_supplicant *wpa_s;
2982         struct wpa_interface t_iface;
2983         struct wpa_ssid *ssid;
2984
2985         if (global == NULL || iface == NULL)
2986                 return NULL;
2987
2988         wpa_s = wpa_supplicant_alloc();
2989         if (wpa_s == NULL)
2990                 return NULL;
2991
2992         wpa_s->global = global;
2993
2994         t_iface = *iface;
2995         if (global->params.override_driver) {
2996                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
2997                            "('%s' -> '%s')",
2998                            iface->driver, global->params.override_driver);
2999                 t_iface.driver = global->params.override_driver;
3000         }
3001         if (global->params.override_ctrl_interface) {
3002                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
3003                            "ctrl_interface ('%s' -> '%s')",
3004                            iface->ctrl_interface,
3005                            global->params.override_ctrl_interface);
3006                 t_iface.ctrl_interface =
3007                         global->params.override_ctrl_interface;
3008         }
3009         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3010                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
3011                            iface->ifname);
3012                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
3013                 os_free(wpa_s);
3014                 return NULL;
3015         }
3016
3017         /* Notify the control interfaces about new iface */
3018         if (wpas_notify_iface_added(wpa_s)) {
3019                 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3020                 os_free(wpa_s);
3021                 return NULL;
3022         }
3023
3024         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3025                 wpas_notify_network_added(wpa_s, ssid);
3026
3027         wpa_s->next = global->ifaces;
3028         global->ifaces = wpa_s;
3029
3030         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
3031         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3032
3033         return wpa_s;
3034 }
3035
3036
3037 /**
3038  * wpa_supplicant_remove_iface - Remove a network interface
3039  * @global: Pointer to global data from wpa_supplicant_init()
3040  * @wpa_s: Pointer to the network interface to be removed
3041  * Returns: 0 if interface was removed, -1 if interface was not found
3042  *
3043  * This function can be used to dynamically remove network interfaces from
3044  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
3045  * addition, this function is used to remove all remaining interfaces when
3046  * %wpa_supplicant is terminated.
3047  */
3048 int wpa_supplicant_remove_iface(struct wpa_global *global,
3049                                 struct wpa_supplicant *wpa_s,
3050                                 int terminate)
3051 {
3052         struct wpa_supplicant *prev;
3053
3054         /* Remove interface from the global list of interfaces */
3055         prev = global->ifaces;
3056         if (prev == wpa_s) {
3057                 global->ifaces = wpa_s->next;
3058         } else {
3059                 while (prev && prev->next != wpa_s)
3060                         prev = prev->next;
3061                 if (prev == NULL)
3062                         return -1;
3063                 prev->next = wpa_s->next;
3064         }
3065
3066         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3067
3068         if (global->p2p_group_formation == wpa_s)
3069                 global->p2p_group_formation = NULL;
3070         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3071         os_free(wpa_s);
3072
3073         return 0;
3074 }
3075
3076
3077 /**
3078  * wpa_supplicant_get_eap_mode - Get the current EAP mode
3079  * @wpa_s: Pointer to the network interface
3080  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
3081  */
3082 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3083 {
3084         const char *eapol_method;
3085
3086         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3087             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3088                 return "NO-EAP";
3089         }
3090
3091         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3092         if (eapol_method == NULL)
3093                 return "UNKNOWN-EAP";
3094
3095         return eapol_method;
3096 }
3097
3098
3099 /**
3100  * wpa_supplicant_get_iface - Get a new network interface
3101  * @global: Pointer to global data from wpa_supplicant_init()
3102  * @ifname: Interface name
3103  * Returns: Pointer to the interface or %NULL if not found
3104  */
3105 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
3106                                                  const char *ifname)
3107 {
3108         struct wpa_supplicant *wpa_s;
3109
3110         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3111                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3112                         return wpa_s;
3113         }
3114         return NULL;
3115 }
3116
3117
3118 #ifndef CONFIG_NO_WPA_MSG
3119 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
3120 {
3121         struct wpa_supplicant *wpa_s = ctx;
3122         if (wpa_s == NULL)
3123                 return NULL;
3124         return wpa_s->ifname;
3125 }
3126 #endif /* CONFIG_NO_WPA_MSG */
3127
3128
3129 /**
3130  * wpa_supplicant_init - Initialize %wpa_supplicant
3131  * @params: Parameters for %wpa_supplicant
3132  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
3133  *
3134  * This function is used to initialize %wpa_supplicant. After successful
3135  * initialization, the returned data pointer can be used to add and remove
3136  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
3137  */
3138 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
3139 {
3140         struct wpa_global *global;
3141         int ret, i;
3142
3143         if (params == NULL)
3144                 return NULL;
3145
3146 #ifdef CONFIG_DRIVER_NDIS
3147         {
3148                 void driver_ndis_init_ops(void);
3149                 driver_ndis_init_ops();
3150         }
3151 #endif /* CONFIG_DRIVER_NDIS */
3152
3153 #ifndef CONFIG_NO_WPA_MSG
3154         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
3155 #endif /* CONFIG_NO_WPA_MSG */
3156
3157         wpa_debug_open_file(params->wpa_debug_file_path);
3158         if (params->wpa_debug_syslog)
3159                 wpa_debug_open_syslog();
3160         if (params->wpa_debug_tracing) {
3161                 ret = wpa_debug_open_linux_tracing();
3162                 if (ret) {
3163                         wpa_printf(MSG_ERROR,
3164                                    "Failed to enable trace logging");
3165                         return NULL;
3166                 }
3167         }
3168
3169         ret = eap_register_methods();
3170         if (ret) {
3171                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
3172                 if (ret == -2)
3173                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
3174                                    "the same EAP type.");
3175                 return NULL;
3176         }
3177
3178         global = os_zalloc(sizeof(*global));
3179         if (global == NULL)
3180                 return NULL;
3181         dl_list_init(&global->p2p_srv_bonjour);
3182         dl_list_init(&global->p2p_srv_upnp);
3183         global->params.daemonize = params->daemonize;
3184         global->params.wait_for_monitor = params->wait_for_monitor;
3185         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
3186         if (params->pid_file)
3187                 global->params.pid_file = os_strdup(params->pid_file);
3188         if (params->ctrl_interface)
3189                 global->params.ctrl_interface =
3190                         os_strdup(params->ctrl_interface);
3191         if (params->override_driver)
3192                 global->params.override_driver =
3193                         os_strdup(params->override_driver);
3194         if (params->override_ctrl_interface)
3195                 global->params.override_ctrl_interface =
3196                         os_strdup(params->override_ctrl_interface);
3197         wpa_debug_level = global->params.wpa_debug_level =
3198                 params->wpa_debug_level;
3199         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
3200                 params->wpa_debug_show_keys;
3201         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
3202                 params->wpa_debug_timestamp;
3203
3204         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
3205
3206         if (eloop_init()) {
3207                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
3208                 wpa_supplicant_deinit(global);
3209                 return NULL;
3210         }
3211
3212         random_init(params->entropy_file);
3213
3214         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
3215         if (global->ctrl_iface == NULL) {
3216                 wpa_supplicant_deinit(global);
3217                 return NULL;
3218         }
3219
3220         if (wpas_notify_supplicant_initialized(global)) {
3221                 wpa_supplicant_deinit(global);
3222                 return NULL;
3223         }
3224
3225         for (i = 0; wpa_drivers[i]; i++)
3226                 global->drv_count++;
3227         if (global->drv_count == 0) {
3228                 wpa_printf(MSG_ERROR, "No drivers enabled");
3229                 wpa_supplicant_deinit(global);
3230                 return NULL;
3231         }
3232         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
3233         if (global->drv_priv == NULL) {
3234                 wpa_supplicant_deinit(global);
3235                 return NULL;
3236         }
3237
3238 #ifdef CONFIG_WIFI_DISPLAY
3239         if (wifi_display_init(global) < 0) {
3240                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
3241                 wpa_supplicant_deinit(global);
3242                 return NULL;
3243         }
3244 #endif /* CONFIG_WIFI_DISPLAY */
3245
3246         return global;
3247 }
3248
3249
3250 /**
3251  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
3252  * @global: Pointer to global data from wpa_supplicant_init()
3253  * Returns: 0 after successful event loop run, -1 on failure
3254  *
3255  * This function starts the main event loop and continues running as long as
3256  * there are any remaining events. In most cases, this function is running as
3257  * long as the %wpa_supplicant process in still in use.
3258  */
3259 int wpa_supplicant_run(struct wpa_global *global)
3260 {
3261         struct wpa_supplicant *wpa_s;
3262
3263         if (global->params.daemonize &&
3264             wpa_supplicant_daemon(global->params.pid_file))
3265                 return -1;
3266
3267         if (global->params.wait_for_monitor) {
3268                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
3269                         if (wpa_s->ctrl_iface)
3270                                 wpa_supplicant_ctrl_iface_wait(
3271                                         wpa_s->ctrl_iface);
3272         }
3273
3274         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
3275         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
3276
3277         eloop_run();
3278
3279         return 0;
3280 }
3281
3282
3283 /**
3284  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
3285  * @global: Pointer to global data from wpa_supplicant_init()
3286  *
3287  * This function is called to deinitialize %wpa_supplicant and to free all
3288  * allocated resources. Remaining network interfaces will also be removed.
3289  */
3290 void wpa_supplicant_deinit(struct wpa_global *global)
3291 {
3292         int i;
3293
3294         if (global == NULL)
3295                 return;
3296
3297 #ifdef CONFIG_WIFI_DISPLAY
3298         wifi_display_deinit(global);
3299 #endif /* CONFIG_WIFI_DISPLAY */
3300 #ifdef CONFIG_P2P
3301         wpas_p2p_deinit_global(global);
3302 #endif /* CONFIG_P2P */
3303
3304         while (global->ifaces)
3305                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
3306
3307         if (global->ctrl_iface)
3308                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
3309
3310         wpas_notify_supplicant_deinitialized(global);
3311
3312         eap_peer_unregister_methods();
3313 #ifdef CONFIG_AP
3314         eap_server_unregister_methods();
3315 #endif /* CONFIG_AP */
3316
3317         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
3318                 if (!global->drv_priv[i])
3319                         continue;
3320                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
3321         }
3322         os_free(global->drv_priv);
3323
3324         random_deinit();
3325
3326         eloop_destroy();
3327
3328         if (global->params.pid_file) {
3329                 os_daemonize_terminate(global->params.pid_file);
3330                 os_free(global->params.pid_file);
3331         }
3332         os_free(global->params.ctrl_interface);
3333         os_free(global->params.override_driver);
3334         os_free(global->params.override_ctrl_interface);
3335
3336         os_free(global->p2p_disallow_freq);
3337
3338         os_free(global);
3339         wpa_debug_close_syslog();
3340         wpa_debug_close_file();
3341         wpa_debug_close_linux_tracing();
3342 }
3343
3344
3345 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
3346 {
3347         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
3348             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3349                 char country[3];
3350                 country[0] = wpa_s->conf->country[0];
3351                 country[1] = wpa_s->conf->country[1];
3352                 country[2] = '\0';
3353                 if (wpa_drv_set_country(wpa_s, country) < 0) {
3354                         wpa_printf(MSG_ERROR, "Failed to set country code "
3355                                    "'%s'", country);
3356                 }
3357         }
3358
3359         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
3360                 wpas_init_ext_pw(wpa_s);
3361
3362 #ifdef CONFIG_WPS
3363         wpas_wps_update_config(wpa_s);
3364 #endif /* CONFIG_WPS */
3365
3366 #ifdef CONFIG_P2P
3367         wpas_p2p_update_config(wpa_s);
3368 #endif /* CONFIG_P2P */
3369
3370         wpa_s->conf->changed_parameters = 0;
3371 }
3372
3373
3374 static void add_freq(int *freqs, int *num_freqs, int freq)
3375 {
3376         int i;
3377
3378         for (i = 0; i < *num_freqs; i++) {
3379                 if (freqs[i] == freq)
3380                         return;
3381         }
3382
3383         freqs[*num_freqs] = freq;
3384         (*num_freqs)++;
3385 }
3386
3387
3388 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
3389 {
3390         struct wpa_bss *bss, *cbss;
3391         const int max_freqs = 10;
3392         int *freqs;
3393         int num_freqs = 0;
3394
3395         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
3396         if (freqs == NULL)
3397                 return NULL;
3398
3399         cbss = wpa_s->current_bss;
3400
3401         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
3402                 if (bss == cbss)
3403                         continue;
3404                 if (bss->ssid_len == cbss->ssid_len &&
3405                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
3406                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
3407                         add_freq(freqs, &num_freqs, bss->freq);
3408                         if (num_freqs == max_freqs)
3409                                 break;
3410                 }
3411         }
3412
3413         if (num_freqs == 0) {
3414                 os_free(freqs);
3415                 freqs = NULL;
3416         }
3417
3418         return freqs;
3419 }
3420
3421
3422 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
3423 {
3424         int timeout;
3425         int count;
3426         int *freqs = NULL;
3427
3428         /*
3429          * Remove possible authentication timeout since the connection failed.
3430          */
3431         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3432
3433         /*
3434          * Add the failed BSSID into the blacklist and speed up next scan
3435          * attempt if there could be other APs that could accept association.
3436          * The current blacklist count indicates how many times we have tried
3437          * connecting to this AP and multiple attempts mean that other APs are
3438          * either not available or has already been tried, so that we can start
3439          * increasing the delay here to avoid constant scanning.
3440          */
3441         count = wpa_blacklist_add(wpa_s, bssid);
3442         if (count == 1 && wpa_s->current_bss) {
3443                 /*
3444                  * This BSS was not in the blacklist before. If there is
3445                  * another BSS available for the same ESS, we should try that
3446                  * next. Otherwise, we may as well try this one once more
3447                  * before allowing other, likely worse, ESSes to be considered.
3448                  */
3449                 freqs = get_bss_freqs_in_ess(wpa_s);
3450                 if (freqs) {
3451                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
3452                                 "has been seen; try it next");
3453                         wpa_blacklist_add(wpa_s, bssid);
3454                         /*
3455                          * On the next scan, go through only the known channels
3456                          * used in this ESS based on previous scans to speed up
3457                          * common load balancing use case.
3458                          */
3459                         os_free(wpa_s->next_scan_freqs);
3460                         wpa_s->next_scan_freqs = freqs;
3461                 }
3462         }
3463
3464         /*
3465          * Add previous failure count in case the temporary blacklist was
3466          * cleared due to no other BSSes being available.
3467          */
3468         count += wpa_s->extra_blacklist_count;
3469
3470         switch (count) {
3471         case 1:
3472                 timeout = 100;
3473                 break;
3474         case 2:
3475                 timeout = 500;
3476                 break;
3477         case 3:
3478                 timeout = 1000;
3479                 break;
3480         case 4:
3481                 timeout = 5000;
3482                 break;
3483         default:
3484                 timeout = 10000;
3485                 break;
3486         }
3487
3488         wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
3489                 "ms", count, timeout);
3490
3491         /*
3492          * TODO: if more than one possible AP is available in scan results,
3493          * could try the other ones before requesting a new scan.
3494          */
3495         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
3496                                 1000 * (timeout % 1000));
3497
3498 #ifdef CONFIG_P2P
3499         if (wpa_s->global->p2p_cb_on_scan_complete && !wpa_s->global->p2p_disabled &&
3500             wpa_s->global->p2p != NULL) {
3501                 wpa_s->global->p2p_cb_on_scan_complete = 0;
3502                 if (p2p_other_scan_completed(wpa_s->global->p2p) == 1) {
3503                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Pending P2P operation "
3504                                 "continued after failed association");
3505                 }
3506         }
3507 #endif /* CONFIG_P2P */
3508 }
3509
3510
3511 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
3512 {
3513         return wpa_s->conf->ap_scan == 2 ||
3514                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
3515 }
3516
3517
3518 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
3519 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
3520                                               struct wpa_ssid *ssid,
3521                                               const char *field,
3522                                               const char *value)
3523 {
3524 #ifdef IEEE8021X_EAPOL
3525         struct eap_peer_config *eap = &ssid->eap;
3526
3527         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
3528         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
3529                               (const u8 *) value, os_strlen(value));
3530
3531         switch (wpa_supplicant_ctrl_req_from_string(field)) {
3532         case WPA_CTRL_REQ_EAP_IDENTITY:
3533                 os_free(eap->identity);
3534                 eap->identity = (u8 *) os_strdup(value);
3535                 eap->identity_len = os_strlen(value);
3536                 eap->pending_req_identity = 0;
3537                 if (ssid == wpa_s->current_ssid)
3538                         wpa_s->reassociate = 1;
3539                 break;
3540         case WPA_CTRL_REQ_EAP_PASSWORD:
3541                 os_free(eap->password);
3542                 eap->password = (u8 *) os_strdup(value);
3543                 eap->password_len = os_strlen(value);
3544                 eap->pending_req_password = 0;
3545                 if (ssid == wpa_s->current_ssid)
3546                         wpa_s->reassociate = 1;
3547                 break;
3548         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
3549                 os_free(eap->new_password);
3550                 eap->new_password = (u8 *) os_strdup(value);
3551                 eap->new_password_len = os_strlen(value);
3552                 eap->pending_req_new_password = 0;
3553                 if (ssid == wpa_s->current_ssid)
3554                         wpa_s->reassociate = 1;
3555                 break;
3556         case WPA_CTRL_REQ_EAP_PIN:
3557                 os_free(eap->pin);
3558                 eap->pin = os_strdup(value);
3559                 eap->pending_req_pin = 0;
3560                 if (ssid == wpa_s->current_ssid)
3561                         wpa_s->reassociate = 1;
3562                 break;
3563         case WPA_CTRL_REQ_EAP_OTP:
3564                 os_free(eap->otp);
3565                 eap->otp = (u8 *) os_strdup(value);
3566                 eap->otp_len = os_strlen(value);
3567                 os_free(eap->pending_req_otp);
3568                 eap->pending_req_otp = NULL;
3569                 eap->pending_req_otp_len = 0;
3570                 break;
3571         case WPA_CTRL_REQ_EAP_PASSPHRASE:
3572                 os_free(eap->private_key_passwd);
3573                 eap->private_key_passwd = (u8 *) os_strdup(value);
3574                 eap->pending_req_passphrase = 0;
3575                 if (ssid == wpa_s->current_ssid)
3576                         wpa_s->reassociate = 1;
3577                 break;
3578         default:
3579                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
3580                 return -1;
3581         }
3582
3583         return 0;
3584 #else /* IEEE8021X_EAPOL */
3585         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
3586         return -1;
3587 #endif /* IEEE8021X_EAPOL */
3588 }
3589 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
3590
3591
3592 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
3593 {
3594         int i;
3595         unsigned int drv_enc;
3596
3597         if (ssid == NULL)
3598                 return 1;
3599
3600         if (ssid->disabled)
3601                 return 1;
3602
3603         if (wpa_s && wpa_s->drv_capa_known)
3604                 drv_enc = wpa_s->drv_enc;
3605         else
3606                 drv_enc = (unsigned int) -1;
3607
3608         for (i = 0; i < NUM_WEP_KEYS; i++) {
3609                 size_t len = ssid->wep_key_len[i];
3610                 if (len == 0)
3611                         continue;
3612                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
3613                         continue;
3614                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
3615                         continue;
3616                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
3617                         continue;
3618                 return 1; /* invalid WEP key */
3619         }
3620
3621         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
3622             !ssid->ext_psk)
3623                 return 1;
3624
3625         return 0;
3626 }
3627
3628
3629 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
3630 {
3631         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
3632                 return 1;
3633         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
3634                 return 0;
3635         return -1;
3636 }
3637
3638
3639 void wpas_auth_failed(struct wpa_supplicant *wpa_s)
3640 {
3641         struct wpa_ssid *ssid = wpa_s->current_ssid;
3642         int dur;
3643         struct os_time now;
3644
3645         if (ssid == NULL) {
3646                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
3647                            "SSID block");
3648                 return;
3649         }
3650
3651         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
3652                 return;
3653
3654         ssid->auth_failures++;
3655         if (ssid->auth_failures > 50)
3656                 dur = 300;
3657         else if (ssid->auth_failures > 20)
3658                 dur = 120;
3659         else if (ssid->auth_failures > 10)
3660                 dur = 60;
3661         else if (ssid->auth_failures > 5)
3662                 dur = 30;
3663         else if (ssid->auth_failures > 1)
3664                 dur = 20;
3665         else
3666                 dur = 10;
3667
3668         os_get_time(&now);
3669         if (now.sec + dur <= ssid->disabled_until.sec)
3670                 return;
3671
3672         ssid->disabled_until.sec = now.sec + dur;
3673
3674         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
3675                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d",
3676                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
3677                 ssid->auth_failures, dur);
3678 }
3679
3680
3681 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
3682                               struct wpa_ssid *ssid, int clear_failures)
3683 {
3684         if (ssid == NULL)
3685                 return;
3686
3687         if (ssid->disabled_until.sec) {
3688                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
3689                         "id=%d ssid=\"%s\"",
3690                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
3691         }
3692         ssid->disabled_until.sec = 0;
3693         ssid->disabled_until.usec = 0;
3694         if (clear_failures)
3695                 ssid->auth_failures = 0;
3696 }
3697
3698
3699 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
3700 {
3701         size_t i;
3702
3703         if (wpa_s->disallow_aps_bssid == NULL)
3704                 return 0;
3705
3706         for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
3707                 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
3708                               bssid, ETH_ALEN) == 0)
3709                         return 1;
3710         }
3711
3712         return 0;
3713 }
3714
3715
3716 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
3717                     size_t ssid_len)
3718 {
3719         size_t i;
3720
3721         if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
3722                 return 0;
3723
3724         for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
3725                 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
3726                 if (ssid_len == s->ssid_len &&
3727                     os_memcmp(ssid, s->ssid, ssid_len) == 0)
3728                         return 1;
3729         }
3730
3731         return 0;
3732 }
3733
3734
3735 /**
3736  * wpas_request_connection - Request a new connection
3737  * @wpa_s: Pointer to the network interface
3738  *
3739  * This function is used to request a new connection to be found. It will mark
3740  * the interface to allow reassociation and request a new scan to find a
3741  * suitable network to connect to.
3742  */
3743 void wpas_request_connection(struct wpa_supplicant *wpa_s)
3744 {
3745         wpa_s->normal_scans = 0;
3746         wpa_supplicant_reinit_autoscan(wpa_s);
3747         wpa_s->extra_blacklist_count = 0;
3748         wpa_s->disconnected = 0;
3749         wpa_s->reassociate = 1;
3750
3751         if (wpa_supplicant_fast_associate(wpa_s) != 1)
3752                 wpa_supplicant_req_scan(wpa_s, 0, 0);
3753 }