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