wpa_supplicant/wpa_supplicant.c

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