wpa_supplicant/wpa_supplicant.c

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