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