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