wpa_supplicant/wpa_supplicant.c

   1 /*
   2  * WPA Supplicant
   3  * Copyright (c) 2003-2015, 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_peer/eap_proxy.h"
  21 #include "eap_server/eap_methods.h"
  22 #include "rsn_supp/wpa.h"
  23 #include "eloop.h"
  24 #include "config.h"
  25 #include "utils/ext_password.h"
  26 #include "l2_packet/l2_packet.h"
  27 #include "wpa_supplicant_i.h"
  28 #include "driver_i.h"
  29 #include "ctrl_iface.h"
  30 #include "pcsc_funcs.h"
  31 #include "common/version.h"
  32 #include "rsn_supp/preauth.h"
  33 #include "rsn_supp/pmksa_cache.h"
  34 #include "common/wpa_ctrl.h"
  35 #include "common/ieee802_11_defs.h"
  36 #include "common/hw_features_common.h"
  37 #include "p2p/p2p.h"
  38 #include "blacklist.h"
  39 #include "wpas_glue.h"
  40 #include "wps_supplicant.h"
  41 #include "ibss_rsn.h"
  42 #include "sme.h"
  43 #include "gas_query.h"
  44 #include "ap.h"
  45 #include "p2p_supplicant.h"
  46 #include "wifi_display.h"
  47 #include "notify.h"
  48 #include "bgscan.h"
  49 #include "autoscan.h"
  50 #include "bss.h"
  51 #include "scan.h"
  52 #include "offchannel.h"
  53 #include "hs20_supplicant.h"
  54 #include "wnm_sta.h"
  55 #include "wpas_kay.h"
  56 #include "mesh.h"
  57
  58 const char *const wpa_supplicant_version =
  59 "wpa_supplicant v" VERSION_STR "\n"
  60 "Copyright (c) 2003-2015, Jouni Malinen <j@w1.fi> and contributors";
  61
  62 const char *const wpa_supplicant_license =
  63 "This software may be distributed under the terms of the BSD license.\n"
  64 "See README for more details.\n"
  65 #ifdef EAP_TLS_OPENSSL
  66 "\nThis product includes software developed by the OpenSSL Project\n"
  67 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
  68 #endif /* EAP_TLS_OPENSSL */
  69 ;
  70
  71 #ifndef CONFIG_NO_STDOUT_DEBUG
  72 /* Long text divided into parts in order to fit in C89 strings size limits. */
  73 const char *const wpa_supplicant_full_license1 =
  74 "";
  75 const char *const wpa_supplicant_full_license2 =
  76 "This software may be distributed under the terms of the BSD license.\n"
  77 "\n"
  78 "Redistribution and use in source and binary forms, with or without\n"
  79 "modification, are permitted provided that the following conditions are\n"
  80 "met:\n"
  81 "\n";
  82 const char *const wpa_supplicant_full_license3 =
  83 "1. Redistributions of source code must retain the above copyright\n"
  84 "   notice, this list of conditions and the following disclaimer.\n"
  85 "\n"
  86 "2. Redistributions in binary form must reproduce the above copyright\n"
  87 "   notice, this list of conditions and the following disclaimer in the\n"
  88 "   documentation and/or other materials provided with the distribution.\n"
  89 "\n";
  90 const char *const wpa_supplicant_full_license4 =
  91 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
  92 "   names of its contributors may be used to endorse or promote products\n"
  93 "   derived from this software without specific prior written permission.\n"
  94 "\n"
  95 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
  96 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
  97 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
  98 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
  99 const char *const wpa_supplicant_full_license5 =
 100 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
 101 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
 102 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
 103 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
 104 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
 105 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
 106 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
 107 "\n";
 108 #endif /* CONFIG_NO_STDOUT_DEBUG */
 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 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         int ret;
 137
 138         /* IBSS/WPA-None uses only one key (Group) for both receiving and
 139          * sending unicast and multicast packets. */
 140
 141         if (ssid->mode != WPAS_MODE_IBSS) {
 142                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
 143                         "IBSS/ad-hoc) for WPA-None", ssid->mode);
 144                 return -1;
 145         }
 146
 147         if (!ssid->psk_set) {
 148                 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
 149                         "WPA-None");
 150                 return -1;
 151         }
 152
 153         switch (wpa_s->group_cipher) {
 154         case WPA_CIPHER_CCMP:
 155                 os_memcpy(key, ssid->psk, 16);
 156                 keylen = 16;
 157                 alg = WPA_ALG_CCMP;
 158                 break;
 159         case WPA_CIPHER_GCMP:
 160                 os_memcpy(key, ssid->psk, 16);
 161                 keylen = 16;
 162                 alg = WPA_ALG_GCMP;
 163                 break;
 164         case WPA_CIPHER_TKIP:
 165                 /* WPA-None uses the same Michael MIC key for both TX and RX */
 166                 os_memcpy(key, ssid->psk, 16 + 8);
 167                 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
 168                 keylen = 32;
 169                 alg = WPA_ALG_TKIP;
 170                 break;
 171         default:
 172                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
 173                         "WPA-None", wpa_s->group_cipher);
 174                 return -1;
 175         }
 176
 177         /* TODO: should actually remember the previously used seq#, both for TX
 178          * and RX from each STA.. */
 179
 180         ret = wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
 181         os_memset(key, 0, sizeof(key));
 182         return ret;
 183 }
 184
 185
 186 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 187 {
 188         struct wpa_supplicant *wpa_s = eloop_ctx;
 189         const u8 *bssid = wpa_s->bssid;
 190         if (is_zero_ether_addr(bssid))
 191                 bssid = wpa_s->pending_bssid;
 192         wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
 193                 MAC2STR(bssid));
 194         wpa_blacklist_add(wpa_s, bssid);
 195         wpa_sm_notify_disassoc(wpa_s->wpa);
 196         wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 197         wpa_s->reassociate = 1;
 198
 199         /*
 200          * If we timed out, the AP or the local radio may be busy.
 201          * So, wait a second until scanning again.
 202          */
 203         wpa_supplicant_req_scan(wpa_s, 1, 0);
 204 }
 205
 206
 207 /**
 208  * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
 209  * @wpa_s: Pointer to wpa_supplicant data
 210  * @sec: Number of seconds after which to time out authentication
 211  * @usec: Number of microseconds after which to time out authentication
 212  *
 213  * This function is used to schedule a timeout for the current authentication
 214  * attempt.
 215  */
 216 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 217                                      int sec, int usec)
 218 {
 219         if (wpa_s->conf->ap_scan == 0 &&
 220             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 221                 return;
 222
 223         wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
 224                 "%d usec", sec, usec);
 225         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 226         eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
 227 }
 228
 229
 230 /**
 231  * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
 232  * @wpa_s: Pointer to wpa_supplicant data
 233  *
 234  * This function is used to cancel authentication timeout scheduled with
 235  * wpa_supplicant_req_auth_timeout() and it is called when authentication has
 236  * been completed.
 237  */
 238 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 239 {
 240         wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
 241         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 242         wpa_blacklist_del(wpa_s, wpa_s->bssid);
 243 }
 244
 245
 246 /**
 247  * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
 248  * @wpa_s: Pointer to wpa_supplicant data
 249  *
 250  * This function is used to configure EAPOL state machine based on the selected
 251  * authentication mode.
 252  */
 253 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
 254 {
 255 #ifdef IEEE8021X_EAPOL
 256         struct eapol_config eapol_conf;
 257         struct wpa_ssid *ssid = wpa_s->current_ssid;
 258
 259 #ifdef CONFIG_IBSS_RSN
 260         if (ssid->mode == WPAS_MODE_IBSS &&
 261             wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
 262             wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
 263                 /*
 264                  * RSN IBSS authentication is per-STA and we can disable the
 265                  * per-BSSID EAPOL authentication.
 266                  */
 267                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 268                 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
 269                 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 270                 return;
 271         }
 272 #endif /* CONFIG_IBSS_RSN */
 273
 274         eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 275         eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 276
 277         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
 278             wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
 279                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 280         else
 281                 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
 282
 283         os_memset(&eapol_conf, 0, sizeof(eapol_conf));
 284         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 285                 eapol_conf.accept_802_1x_keys = 1;
 286                 eapol_conf.required_keys = 0;
 287                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
 288                         eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
 289                 }
 290                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
 291                         eapol_conf.required_keys |=
 292                                 EAPOL_REQUIRE_KEY_BROADCAST;
 293                 }
 294
 295                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
 296                         eapol_conf.required_keys = 0;
 297         }
 298         eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
 299         eapol_conf.workaround = ssid->eap_workaround;
 300         eapol_conf.eap_disabled =
 301                 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
 302                 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
 303                 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
 304         eapol_conf.external_sim = wpa_s->conf->external_sim;
 305
 306 #ifdef CONFIG_WPS
 307         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
 308                 eapol_conf.wps |= EAPOL_LOCAL_WPS_IN_USE;
 309                 if (wpa_s->current_bss) {
 310                         struct wpabuf *ie;
 311                         ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
 312                                                          WPS_IE_VENDOR_TYPE);
 313                         if (ie) {
 314                                 if (wps_is_20(ie))
 315                                         eapol_conf.wps |=
 316                                                 EAPOL_PEER_IS_WPS20_AP;
 317                                 wpabuf_free(ie);
 318                         }
 319                 }
 320         }
 321 #endif /* CONFIG_WPS */
 322
 323         eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
 324
 325         ieee802_1x_alloc_kay_sm(wpa_s, ssid);
 326 #endif /* IEEE8021X_EAPOL */
 327 }
 328
 329
 330 /**
 331  * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
 332  * @wpa_s: Pointer to wpa_supplicant data
 333  * @ssid: Configuration data for the network
 334  *
 335  * This function is used to configure WPA state machine and related parameters
 336  * to a mode where WPA is not enabled. This is called as part of the
 337  * authentication configuration when the selected network does not use WPA.
 338  */
 339 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
 340                                        struct wpa_ssid *ssid)
 341 {
 342         int i;
 343
 344         if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
 345                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
 346         else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
 347                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 348         else
 349                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 350         wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
 351         wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
 352         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 353         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 354         wpa_s->group_cipher = WPA_CIPHER_NONE;
 355         wpa_s->mgmt_group_cipher = 0;
 356
 357         for (i = 0; i < NUM_WEP_KEYS; i++) {
 358                 if (ssid->wep_key_len[i] > 5) {
 359                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
 360                         wpa_s->group_cipher = WPA_CIPHER_WEP104;
 361                         break;
 362                 } else if (ssid->wep_key_len[i] > 0) {
 363                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
 364                         wpa_s->group_cipher = WPA_CIPHER_WEP40;
 365                         break;
 366                 }
 367         }
 368
 369         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
 370         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 371         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 372                          wpa_s->pairwise_cipher);
 373         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 374 #ifdef CONFIG_IEEE80211W
 375         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 376                          wpa_s->mgmt_group_cipher);
 377 #endif /* CONFIG_IEEE80211W */
 378
 379         pmksa_cache_clear_current(wpa_s->wpa);
 380 }
 381
 382
 383 void free_hw_features(struct wpa_supplicant *wpa_s)
 384 {
 385         int i;
 386         if (wpa_s->hw.modes == NULL)
 387                 return;
 388
 389         for (i = 0; i < wpa_s->hw.num_modes; i++) {
 390                 os_free(wpa_s->hw.modes[i].channels);
 391                 os_free(wpa_s->hw.modes[i].rates);
 392         }
 393
 394         os_free(wpa_s->hw.modes);
 395         wpa_s->hw.modes = NULL;
 396 }
 397
 398
 399 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 400 {
 401         int i;
 402
 403         bgscan_deinit(wpa_s);
 404         autoscan_deinit(wpa_s);
 405         scard_deinit(wpa_s->scard);
 406         wpa_s->scard = NULL;
 407         wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
 408         eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
 409         l2_packet_deinit(wpa_s->l2);
 410         wpa_s->l2 = NULL;
 411         if (wpa_s->l2_br) {
 412                 l2_packet_deinit(wpa_s->l2_br);
 413                 wpa_s->l2_br = NULL;
 414         }
 415 #ifdef CONFIG_TESTING_OPTIONS
 416         l2_packet_deinit(wpa_s->l2_test);
 417         wpa_s->l2_test = NULL;
 418 #endif /* CONFIG_TESTING_OPTIONS */
 419
 420         if (wpa_s->conf != NULL) {
 421                 struct wpa_ssid *ssid;
 422                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
 423                         wpas_notify_network_removed(wpa_s, ssid);
 424         }
 425
 426         os_free(wpa_s->confname);
 427         wpa_s->confname = NULL;
 428
 429         os_free(wpa_s->confanother);
 430         wpa_s->confanother = NULL;
 431
 432         wpa_sm_set_eapol(wpa_s->wpa, NULL);
 433         eapol_sm_deinit(wpa_s->eapol);
 434         wpa_s->eapol = NULL;
 435
 436         rsn_preauth_deinit(wpa_s->wpa);
 437
 438 #ifdef CONFIG_TDLS
 439         wpa_tdls_deinit(wpa_s->wpa);
 440 #endif /* CONFIG_TDLS */
 441
 442         wmm_ac_clear_saved_tspecs(wpa_s);
 443         pmksa_candidate_free(wpa_s->wpa);
 444         wpa_sm_deinit(wpa_s->wpa);
 445         wpa_s->wpa = NULL;
 446         wpa_blacklist_clear(wpa_s);
 447
 448         wpa_bss_deinit(wpa_s);
 449
 450         wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
 451         wpa_supplicant_cancel_scan(wpa_s);
 452         wpa_supplicant_cancel_auth_timeout(wpa_s);
 453         eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
 454 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
 455         eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
 456                              wpa_s, NULL);
 457 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
 458
 459         eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
 460
 461         wpas_wps_deinit(wpa_s);
 462
 463         wpabuf_free(wpa_s->pending_eapol_rx);
 464         wpa_s->pending_eapol_rx = NULL;
 465
 466 #ifdef CONFIG_IBSS_RSN
 467         ibss_rsn_deinit(wpa_s->ibss_rsn);
 468         wpa_s->ibss_rsn = NULL;
 469 #endif /* CONFIG_IBSS_RSN */
 470
 471         sme_deinit(wpa_s);
 472
 473 #ifdef CONFIG_AP
 474         wpa_supplicant_ap_deinit(wpa_s);
 475 #endif /* CONFIG_AP */
 476
 477         wpas_p2p_deinit(wpa_s);
 478
 479 #ifdef CONFIG_OFFCHANNEL
 480         offchannel_deinit(wpa_s);
 481 #endif /* CONFIG_OFFCHANNEL */
 482
 483         wpa_supplicant_cancel_sched_scan(wpa_s);
 484
 485         os_free(wpa_s->next_scan_freqs);
 486         wpa_s->next_scan_freqs = NULL;
 487
 488         os_free(wpa_s->manual_scan_freqs);
 489         wpa_s->manual_scan_freqs = NULL;
 490
 491         os_free(wpa_s->manual_sched_scan_freqs);
 492         wpa_s->manual_sched_scan_freqs = NULL;
 493
 494         wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
 495
 496         gas_query_deinit(wpa_s->gas);
 497         wpa_s->gas = NULL;
 498
 499         free_hw_features(wpa_s);
 500
 501         ieee802_1x_dealloc_kay_sm(wpa_s);
 502
 503         os_free(wpa_s->bssid_filter);
 504         wpa_s->bssid_filter = NULL;
 505
 506         os_free(wpa_s->disallow_aps_bssid);
 507         wpa_s->disallow_aps_bssid = NULL;
 508         os_free(wpa_s->disallow_aps_ssid);
 509         wpa_s->disallow_aps_ssid = NULL;
 510
 511         wnm_bss_keep_alive_deinit(wpa_s);
 512 #ifdef CONFIG_WNM
 513         wnm_deallocate_memory(wpa_s);
 514 #endif /* CONFIG_WNM */
 515
 516         ext_password_deinit(wpa_s->ext_pw);
 517         wpa_s->ext_pw = NULL;
 518
 519         wpabuf_free(wpa_s->last_gas_resp);
 520         wpa_s->last_gas_resp = NULL;
 521         wpabuf_free(wpa_s->prev_gas_resp);
 522         wpa_s->prev_gas_resp = NULL;
 523
 524         os_free(wpa_s->last_scan_res);
 525         wpa_s->last_scan_res = NULL;
 526
 527 #ifdef CONFIG_HS20
 528         hs20_deinit(wpa_s);
 529 #endif /* CONFIG_HS20 */
 530
 531         for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
 532                 wpabuf_free(wpa_s->vendor_elem[i]);
 533                 wpa_s->vendor_elem[i] = NULL;
 534         }
 535
 536         wmm_ac_notify_disassoc(wpa_s);
 537 }
 538
 539
 540 /**
 541  * wpa_clear_keys - Clear keys configured for the driver
 542  * @wpa_s: Pointer to wpa_supplicant data
 543  * @addr: Previously used BSSID or %NULL if not available
 544  *
 545  * This function clears the encryption keys that has been previously configured
 546  * for the driver.
 547  */
 548 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
 549 {
 550         int i, max;
 551
 552 #ifdef CONFIG_IEEE80211W
 553         max = 6;
 554 #else /* CONFIG_IEEE80211W */
 555         max = 4;
 556 #endif /* CONFIG_IEEE80211W */
 557
 558         /* MLME-DELETEKEYS.request */
 559         for (i = 0; i < max; i++) {
 560                 if (wpa_s->keys_cleared & BIT(i))
 561                         continue;
 562                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
 563                                 NULL, 0);
 564         }
 565         if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
 566             !is_zero_ether_addr(addr)) {
 567                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
 568                                 0);
 569                 /* MLME-SETPROTECTION.request(None) */
 570                 wpa_drv_mlme_setprotection(
 571                         wpa_s, addr,
 572                         MLME_SETPROTECTION_PROTECT_TYPE_NONE,
 573                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 574         }
 575         wpa_s->keys_cleared = (u32) -1;
 576 }
 577
 578
 579 /**
 580  * wpa_supplicant_state_txt - Get the connection state name as a text string
 581  * @state: State (wpa_state; WPA_*)
 582  * Returns: The state name as a printable text string
 583  */
 584 const char * wpa_supplicant_state_txt(enum wpa_states state)
 585 {
 586         switch (state) {
 587         case WPA_DISCONNECTED:
 588                 return "DISCONNECTED";
 589         case WPA_INACTIVE:
 590                 return "INACTIVE";
 591         case WPA_INTERFACE_DISABLED:
 592                 return "INTERFACE_DISABLED";
 593         case WPA_SCANNING:
 594                 return "SCANNING";
 595         case WPA_AUTHENTICATING:
 596                 return "AUTHENTICATING";
 597         case WPA_ASSOCIATING:
 598                 return "ASSOCIATING";
 599         case WPA_ASSOCIATED:
 600                 return "ASSOCIATED";
 601         case WPA_4WAY_HANDSHAKE:
 602                 return "4WAY_HANDSHAKE";
 603         case WPA_GROUP_HANDSHAKE:
 604                 return "GROUP_HANDSHAKE";
 605         case WPA_COMPLETED:
 606                 return "COMPLETED";
 607         default:
 608                 return "UNKNOWN";
 609         }
 610 }
 611
 612
 613 #ifdef CONFIG_BGSCAN
 614
 615 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
 616 {
 617         const char *name;
 618
 619         if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
 620                 name = wpa_s->current_ssid->bgscan;
 621         else
 622                 name = wpa_s->conf->bgscan;
 623         if (name == NULL || name[0] == '\0')
 624                 return;
 625         if (wpas_driver_bss_selection(wpa_s))
 626                 return;
 627         if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
 628                 return;
 629 #ifdef CONFIG_P2P
 630         if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
 631                 return;
 632 #endif /* CONFIG_P2P */
 633
 634         bgscan_deinit(wpa_s);
 635         if (wpa_s->current_ssid) {
 636                 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
 637                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
 638                                 "bgscan");
 639                         /*
 640                          * Live without bgscan; it is only used as a roaming
 641                          * optimization, so the initial connection is not
 642                          * affected.
 643                          */
 644                 } else {
 645                         struct wpa_scan_results *scan_res;
 646                         wpa_s->bgscan_ssid = wpa_s->current_ssid;
 647                         scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
 648                                                                    0);
 649                         if (scan_res) {
 650                                 bgscan_notify_scan(wpa_s, scan_res);
 651                                 wpa_scan_results_free(scan_res);
 652                         }
 653                 }
 654         } else
 655                 wpa_s->bgscan_ssid = NULL;
 656 }
 657
 658
 659 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
 660 {
 661         if (wpa_s->bgscan_ssid != NULL) {
 662                 bgscan_deinit(wpa_s);
 663                 wpa_s->bgscan_ssid = NULL;
 664         }
 665 }
 666
 667 #endif /* CONFIG_BGSCAN */
 668
 669
 670 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
 671 {
 672         if (autoscan_init(wpa_s, 0))
 673                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
 674 }
 675
 676
 677 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
 678 {
 679         autoscan_deinit(wpa_s);
 680 }
 681
 682
 683 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
 684 {
 685         if (wpa_s->wpa_state == WPA_DISCONNECTED ||
 686             wpa_s->wpa_state == WPA_SCANNING) {
 687                 autoscan_deinit(wpa_s);
 688                 wpa_supplicant_start_autoscan(wpa_s);
 689         }
 690 }
 691
 692
 693 /**
 694  * wpa_supplicant_set_state - Set current connection state
 695  * @wpa_s: Pointer to wpa_supplicant data
 696  * @state: The new connection state
 697  *
 698  * This function is called whenever the connection state changes, e.g.,
 699  * association is completed for WPA/WPA2 4-Way Handshake is started.
 700  */
 701 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
 702                               enum wpa_states state)
 703 {
 704         enum wpa_states old_state = wpa_s->wpa_state;
 705
 706         wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
 707                 wpa_supplicant_state_txt(wpa_s->wpa_state),
 708                 wpa_supplicant_state_txt(state));
 709
 710         if (state == WPA_INTERFACE_DISABLED) {
 711                 /* Assure normal scan when interface is restored */
 712                 wpa_s->normal_scans = 0;
 713         }
 714
 715         if (state == WPA_COMPLETED) {
 716                 wpas_connect_work_done(wpa_s);
 717                 /* Reinitialize normal_scan counter */
 718                 wpa_s->normal_scans = 0;
 719         }
 720
 721         if (state != WPA_SCANNING)
 722                 wpa_supplicant_notify_scanning(wpa_s, 0);
 723
 724         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 725                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 726 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 727                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 728                         MACSTR " completed [id=%d id_str=%s]",
 729                         MAC2STR(wpa_s->bssid),
 730                         ssid ? ssid->id : -1,
 731                         ssid && ssid->id_str ? ssid->id_str : "");
 732 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 733                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
 734                 wpa_blacklist_clear(wpa_s);
 735                 wpa_s->extra_blacklist_count = 0;
 736                 wpa_s->new_connection = 0;
 737                 wpa_drv_set_operstate(wpa_s, 1);
 738 #ifndef IEEE8021X_EAPOL
 739                 wpa_drv_set_supp_port(wpa_s, 1);
 740 #endif /* IEEE8021X_EAPOL */
 741                 wpa_s->after_wps = 0;
 742                 wpa_s->known_wps_freq = 0;
 743                 wpas_p2p_completed(wpa_s);
 744
 745                 sme_sched_obss_scan(wpa_s, 1);
 746         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 747                    state == WPA_ASSOCIATED) {
 748                 wpa_s->new_connection = 1;
 749                 wpa_drv_set_operstate(wpa_s, 0);
 750 #ifndef IEEE8021X_EAPOL
 751                 wpa_drv_set_supp_port(wpa_s, 0);
 752 #endif /* IEEE8021X_EAPOL */
 753                 sme_sched_obss_scan(wpa_s, 0);
 754         }
 755         wpa_s->wpa_state = state;
 756
 757 #ifdef CONFIG_BGSCAN
 758         if (state == WPA_COMPLETED)
 759                 wpa_supplicant_start_bgscan(wpa_s);
 760         else if (state < WPA_ASSOCIATED)
 761                 wpa_supplicant_stop_bgscan(wpa_s);
 762 #endif /* CONFIG_BGSCAN */
 763
 764         if (state == WPA_AUTHENTICATING)
 765                 wpa_supplicant_stop_autoscan(wpa_s);
 766
 767         if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
 768                 wpa_supplicant_start_autoscan(wpa_s);
 769
 770         if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
 771                 wmm_ac_notify_disassoc(wpa_s);
 772
 773         if (wpa_s->wpa_state != old_state) {
 774                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 775
 776                 /*
 777                  * Notify the P2P Device interface about a state change in one
 778                  * of the interfaces.
 779                  */
 780                 wpas_p2p_indicate_state_change(wpa_s);
 781
 782                 if (wpa_s->wpa_state == WPA_COMPLETED ||
 783                     old_state == WPA_COMPLETED)
 784                         wpas_notify_auth_changed(wpa_s);
 785         }
 786 }
 787
 788
 789 void wpa_supplicant_terminate_proc(struct wpa_global *global)
 790 {
 791         int pending = 0;
 792 #ifdef CONFIG_WPS
 793         struct wpa_supplicant *wpa_s = global->ifaces;
 794         while (wpa_s) {
 795                 struct wpa_supplicant *next = wpa_s->next;
 796                 if (wpas_wps_terminate_pending(wpa_s) == 1)
 797                         pending = 1;
 798 #ifdef CONFIG_P2P
 799                 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
 800                     (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
 801                         wpas_p2p_disconnect(wpa_s);
 802 #endif /* CONFIG_P2P */
 803                 wpa_s = next;
 804         }
 805 #endif /* CONFIG_WPS */
 806         if (pending)
 807                 return;
 808         eloop_terminate();
 809 }
 810
 811
 812 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
 813 {
 814         struct wpa_global *global = signal_ctx;
 815         wpa_supplicant_terminate_proc(global);
 816 }
 817
 818
 819 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 820 {
 821         enum wpa_states old_state = wpa_s->wpa_state;
 822
 823         wpa_s->pairwise_cipher = 0;
 824         wpa_s->group_cipher = 0;
 825         wpa_s->mgmt_group_cipher = 0;
 826         wpa_s->key_mgmt = 0;
 827         if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
 828                 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
 829
 830         if (wpa_s->wpa_state != old_state)
 831                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 832 }
 833
 834
 835 /**
 836  * wpa_supplicant_reload_configuration - Reload configuration data
 837  * @wpa_s: Pointer to wpa_supplicant data
 838  * Returns: 0 on success or -1 if configuration parsing failed
 839  *
 840  * This function can be used to request that the configuration data is reloaded
 841  * (e.g., after configuration file change). This function is reloading
 842  * configuration only for one interface, so this may need to be called multiple
 843  * times if %wpa_supplicant is controlling multiple interfaces and all
 844  * interfaces need reconfiguration.
 845  */
 846 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 847 {
 848         struct wpa_config *conf;
 849         int reconf_ctrl;
 850         int old_ap_scan;
 851
 852         if (wpa_s->confname == NULL)
 853                 return -1;
 854         conf = wpa_config_read(wpa_s->confname, NULL);
 855         if (conf == NULL) {
 856                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 857                         "file '%s' - exiting", wpa_s->confname);
 858                 return -1;
 859         }
 860         wpa_config_read(wpa_s->confanother, conf);
 861
 862         conf->changed_parameters = (unsigned int) -1;
 863
 864         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 865                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 866                     os_strcmp(conf->ctrl_interface,
 867                               wpa_s->conf->ctrl_interface) != 0);
 868
 869         if (reconf_ctrl && wpa_s->ctrl_iface) {
 870                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 871                 wpa_s->ctrl_iface = NULL;
 872         }
 873
 874         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 875         if (wpa_s->current_ssid) {
 876                 wpa_s->own_disconnect_req = 1;
 877                 wpa_supplicant_deauthenticate(wpa_s,
 878                                               WLAN_REASON_DEAUTH_LEAVING);
 879         }
 880
 881         /*
 882          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 883          * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
 884          */
 885         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 886                 /*
 887                  * Clear forced success to clear EAP state for next
 888                  * authentication.
 889                  */
 890                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 891         }
 892         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 893         wpa_sm_set_config(wpa_s->wpa, NULL);
 894         wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
 895         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 896         rsn_preauth_deinit(wpa_s->wpa);
 897
 898         old_ap_scan = wpa_s->conf->ap_scan;
 899         wpa_config_free(wpa_s->conf);
 900         wpa_s->conf = conf;
 901         if (old_ap_scan != wpa_s->conf->ap_scan)
 902                 wpas_notify_ap_scan_changed(wpa_s);
 903
 904         if (reconf_ctrl)
 905                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 906
 907         wpa_supplicant_update_config(wpa_s);
 908
 909         wpa_supplicant_clear_status(wpa_s);
 910         if (wpa_supplicant_enabled_networks(wpa_s)) {
 911                 wpa_s->reassociate = 1;
 912                 wpa_supplicant_req_scan(wpa_s, 0, 0);
 913         }
 914         wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 915         return 0;
 916 }
 917
 918
 919 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
 920 {
 921         struct wpa_global *global = signal_ctx;
 922         struct wpa_supplicant *wpa_s;
 923         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 924                 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
 925                         sig);
 926                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 927                         wpa_supplicant_terminate_proc(global);
 928                 }
 929         }
 930 }
 931
 932
 933 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 934                                          struct wpa_ssid *ssid,
 935                                          struct wpa_ie_data *ie)
 936 {
 937         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 938         if (ret) {
 939                 if (ret == -2) {
 940                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 941                                 "from association info");
 942                 }
 943                 return -1;
 944         }
 945
 946         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
 947                 "cipher suites");
 948         if (!(ie->group_cipher & ssid->group_cipher)) {
 949                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
 950                         "cipher 0x%x (mask 0x%x) - reject",
 951                         ie->group_cipher, ssid->group_cipher);
 952                 return -1;
 953         }
 954         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
 955                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
 956                         "cipher 0x%x (mask 0x%x) - reject",
 957                         ie->pairwise_cipher, ssid->pairwise_cipher);
 958                 return -1;
 959         }
 960         if (!(ie->key_mgmt & ssid->key_mgmt)) {
 961                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
 962                         "management 0x%x (mask 0x%x) - reject",
 963                         ie->key_mgmt, ssid->key_mgmt);
 964                 return -1;
 965         }
 966
 967 #ifdef CONFIG_IEEE80211W
 968         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
 969             wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
 970                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
 971                         "that does not support management frame protection - "
 972                         "reject");
 973                 return -1;
 974         }
 975 #endif /* CONFIG_IEEE80211W */
 976
 977         return 0;
 978 }
 979
 980
 981 /**
 982  * wpa_supplicant_set_suites - Set authentication and encryption parameters
 983  * @wpa_s: Pointer to wpa_supplicant data
 984  * @bss: Scan results for the selected BSS, or %NULL if not available
 985  * @ssid: Configuration data for the selected network
 986  * @wpa_ie: Buffer for the WPA/RSN IE
 987  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
 988  * used buffer length in case the functions returns success.
 989  * Returns: 0 on success or -1 on failure
 990  *
 991  * This function is used to configure authentication and encryption parameters
 992  * based on the network configuration and scan result for the selected BSS (if
 993  * available).
 994  */
 995 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 996                               struct wpa_bss *bss, struct wpa_ssid *ssid,
 997                               u8 *wpa_ie, size_t *wpa_ie_len)
 998 {
 999         struct wpa_ie_data ie;
1000         int sel, proto;
1001         const u8 *bss_wpa, *bss_rsn, *bss_osen;
1002
1003         if (bss) {
1004                 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
1005                 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1006                 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
1007         } else
1008                 bss_wpa = bss_rsn = bss_osen = NULL;
1009
1010         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
1011             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
1012             (ie.group_cipher & ssid->group_cipher) &&
1013             (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1014             (ie.key_mgmt & ssid->key_mgmt)) {
1015                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1016                 proto = WPA_PROTO_RSN;
1017         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
1018                    wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie) == 0 &&
1019                    (ie.group_cipher & ssid->group_cipher) &&
1020                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1021                    (ie.key_mgmt & ssid->key_mgmt)) {
1022                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1023                 proto = WPA_PROTO_WPA;
1024 #ifdef CONFIG_HS20
1025         } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN)) {
1026                 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1027                 /* TODO: parse OSEN element */
1028                 os_memset(&ie, 0, sizeof(ie));
1029                 ie.group_cipher = WPA_CIPHER_CCMP;
1030                 ie.pairwise_cipher = WPA_CIPHER_CCMP;
1031                 ie.key_mgmt = WPA_KEY_MGMT_OSEN;
1032                 proto = WPA_PROTO_OSEN;
1033 #endif /* CONFIG_HS20 */
1034         } else if (bss) {
1035                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1036                 wpa_dbg(wpa_s, MSG_DEBUG,
1037                         "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1038                         ssid->proto, ssid->pairwise_cipher, ssid->group_cipher,
1039                         ssid->key_mgmt);
1040                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1041                         MAC2STR(bss->bssid),
1042                         wpa_ssid_txt(bss->ssid, bss->ssid_len),
1043                         bss_wpa ? " WPA" : "",
1044                         bss_rsn ? " RSN" : "",
1045                         bss_osen ? " OSEN" : "");
1046                 if (bss_rsn) {
1047                         wpa_hexdump(MSG_DEBUG, "RSN", bss_rsn, 2 + bss_rsn[1]);
1048                         if (wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie)) {
1049                                 wpa_dbg(wpa_s, MSG_DEBUG,
1050                                         "Could not parse RSN element");
1051                         } else {
1052                                 wpa_dbg(wpa_s, MSG_DEBUG,
1053                                         "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1054                                         ie.pairwise_cipher, ie.group_cipher,
1055                                         ie.key_mgmt);
1056                         }
1057                 }
1058                 if (bss_wpa) {
1059                         wpa_hexdump(MSG_DEBUG, "WPA", bss_wpa, 2 + bss_wpa[1]);
1060                         if (wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie)) {
1061                                 wpa_dbg(wpa_s, MSG_DEBUG,
1062                                         "Could not parse WPA element");
1063                         } else {
1064                                 wpa_dbg(wpa_s, MSG_DEBUG,
1065                                         "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1066                                         ie.pairwise_cipher, ie.group_cipher,
1067                                         ie.key_mgmt);
1068                         }
1069                 }
1070                 return -1;
1071         } else {
1072                 if (ssid->proto & WPA_PROTO_OSEN)
1073                         proto = WPA_PROTO_OSEN;
1074                 else if (ssid->proto & WPA_PROTO_RSN)
1075                         proto = WPA_PROTO_RSN;
1076                 else
1077                         proto = WPA_PROTO_WPA;
1078                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1079                         os_memset(&ie, 0, sizeof(ie));
1080                         ie.group_cipher = ssid->group_cipher;
1081                         ie.pairwise_cipher = ssid->pairwise_cipher;
1082                         ie.key_mgmt = ssid->key_mgmt;
1083 #ifdef CONFIG_IEEE80211W
1084                         ie.mgmt_group_cipher =
1085                                 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
1086                                 WPA_CIPHER_AES_128_CMAC : 0;
1087 #endif /* CONFIG_IEEE80211W */
1088                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1089                                 "based on configuration");
1090                 } else
1091                         proto = ie.proto;
1092         }
1093
1094         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1095                 "pairwise %d key_mgmt %d proto %d",
1096                 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
1097 #ifdef CONFIG_IEEE80211W
1098         if (ssid->ieee80211w) {
1099                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1100                         ie.mgmt_group_cipher);
1101         }
1102 #endif /* CONFIG_IEEE80211W */
1103
1104         wpa_s->wpa_proto = proto;
1105         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1106         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1107                          !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)));
1108
1109         if (bss || !wpa_s->ap_ies_from_associnfo) {
1110                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1111                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
1112                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1113                                          bss_rsn ? 2 + bss_rsn[1] : 0))
1114                         return -1;
1115         }
1116
1117         sel = ie.group_cipher & ssid->group_cipher;
1118         wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1119         if (wpa_s->group_cipher < 0) {
1120                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1121                         "cipher");
1122                 return -1;
1123         }
1124         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1125                 wpa_cipher_txt(wpa_s->group_cipher));
1126
1127         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
1128         wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1129         if (wpa_s->pairwise_cipher < 0) {
1130                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1131                         "cipher");
1132                 return -1;
1133         }
1134         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1135                 wpa_cipher_txt(wpa_s->pairwise_cipher));
1136
1137         sel = ie.key_mgmt & ssid->key_mgmt;
1138 #ifdef CONFIG_SAE
1139         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1140                 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
1141 #endif /* CONFIG_SAE */
1142         if (0) {
1143 #ifdef CONFIG_SUITEB192
1144         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
1145                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1146                 wpa_dbg(wpa_s, MSG_DEBUG,
1147                         "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)");
1148 #endif /* CONFIG_SUITEB192 */
1149 #ifdef CONFIG_SUITEB
1150         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1151                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1152                 wpa_dbg(wpa_s, MSG_DEBUG,
1153                         "WPA: using KEY_MGMT 802.1X with Suite B");
1154 #endif /* CONFIG_SUITEB */
1155 #ifdef CONFIG_IEEE80211R
1156         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1157                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1158                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1159         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1160                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1161                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1162 #endif /* CONFIG_IEEE80211R */
1163 #ifdef CONFIG_SAE
1164         } else if (sel & WPA_KEY_MGMT_SAE) {
1165                 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1166                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1167         } else if (sel & WPA_KEY_MGMT_FT_SAE) {
1168                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1169                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1170 #endif /* CONFIG_SAE */
1171 #ifdef CONFIG_IEEE80211W
1172         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1173                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1174                 wpa_dbg(wpa_s, MSG_DEBUG,
1175                         "WPA: using KEY_MGMT 802.1X with SHA256");
1176         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1177                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1178                 wpa_dbg(wpa_s, MSG_DEBUG,
1179                         "WPA: using KEY_MGMT PSK with SHA256");
1180 #endif /* CONFIG_IEEE80211W */
1181         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1182                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1183                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1184         } else if (sel & WPA_KEY_MGMT_PSK) {
1185                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1186                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1187         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1188                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1189                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1190 #ifdef CONFIG_HS20
1191         } else if (sel & WPA_KEY_MGMT_OSEN) {
1192                 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1193                 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1194 #endif /* CONFIG_HS20 */
1195         } else {
1196                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1197                         "authenticated key management type");
1198                 return -1;
1199         }
1200
1201         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1202         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1203                          wpa_s->pairwise_cipher);
1204         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1205
1206 #ifdef CONFIG_IEEE80211W
1207         sel = ie.mgmt_group_cipher;
1208         if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1209             !(ie.capabilities & WPA_CAPABILITY_MFPC))
1210                 sel = 0;
1211         if (sel & WPA_CIPHER_AES_128_CMAC) {
1212                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1213                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1214                         "AES-128-CMAC");
1215         } else if (sel & WPA_CIPHER_BIP_GMAC_128) {
1216                 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1217                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1218                         "BIP-GMAC-128");
1219         } else if (sel & WPA_CIPHER_BIP_GMAC_256) {
1220                 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1221                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1222                         "BIP-GMAC-256");
1223         } else if (sel & WPA_CIPHER_BIP_CMAC_256) {
1224                 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1225                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1226                         "BIP-CMAC-256");
1227         } else {
1228                 wpa_s->mgmt_group_cipher = 0;
1229                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1230         }
1231         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1232                          wpa_s->mgmt_group_cipher);
1233         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1234                          wpas_get_ssid_pmf(wpa_s, ssid));
1235 #endif /* CONFIG_IEEE80211W */
1236
1237         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1238                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1239                 return -1;
1240         }
1241
1242         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
1243                 int psk_set = 0;
1244
1245                 if (ssid->psk_set) {
1246                         wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL);
1247                         psk_set = 1;
1248                 }
1249 #ifndef CONFIG_NO_PBKDF2
1250                 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1251                     ssid->passphrase) {
1252                         u8 psk[PMK_LEN];
1253                         pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1254                                     4096, psk, PMK_LEN);
1255                         wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1256                                         psk, PMK_LEN);
1257                         wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL);
1258                         psk_set = 1;
1259                         os_memset(psk, 0, sizeof(psk));
1260                 }
1261 #endif /* CONFIG_NO_PBKDF2 */
1262 #ifdef CONFIG_EXT_PASSWORD
1263                 if (ssid->ext_psk) {
1264                         struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1265                                                              ssid->ext_psk);
1266                         char pw_str[64 + 1];
1267                         u8 psk[PMK_LEN];
1268
1269                         if (pw == NULL) {
1270                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1271                                         "found from external storage");
1272                                 return -1;
1273                         }
1274
1275                         if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1276                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1277                                         "PSK length %d in external storage",
1278                                         (int) wpabuf_len(pw));
1279                                 ext_password_free(pw);
1280                                 return -1;
1281                         }
1282
1283                         os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1284                         pw_str[wpabuf_len(pw)] = '\0';
1285
1286 #ifndef CONFIG_NO_PBKDF2
1287                         if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1288                         {
1289                                 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1290                                             4096, psk, PMK_LEN);
1291                                 os_memset(pw_str, 0, sizeof(pw_str));
1292                                 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1293                                                 "external passphrase)",
1294                                                 psk, PMK_LEN);
1295                                 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL);
1296                                 psk_set = 1;
1297                                 os_memset(psk, 0, sizeof(psk));
1298                         } else
1299 #endif /* CONFIG_NO_PBKDF2 */
1300                         if (wpabuf_len(pw) == 2 * PMK_LEN) {
1301                                 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1302                                         wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1303                                                 "Invalid PSK hex string");
1304                                         os_memset(pw_str, 0, sizeof(pw_str));
1305                                         ext_password_free(pw);
1306                                         return -1;
1307                                 }
1308                                 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL);
1309                                 psk_set = 1;
1310                                 os_memset(psk, 0, sizeof(psk));
1311                         } else {
1312                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1313                                         "PSK available");
1314                                 os_memset(pw_str, 0, sizeof(pw_str));
1315                                 ext_password_free(pw);
1316                                 return -1;
1317                         }
1318
1319                         os_memset(pw_str, 0, sizeof(pw_str));
1320                         ext_password_free(pw);
1321                 }
1322 #endif /* CONFIG_EXT_PASSWORD */
1323
1324                 if (!psk_set) {
1325                         wpa_msg(wpa_s, MSG_INFO,
1326                                 "No PSK available for association");
1327                         return -1;
1328                 }
1329         } else
1330                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1331
1332         return 0;
1333 }
1334
1335
1336 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1337 {
1338         *pos = 0x00;
1339
1340         switch (idx) {
1341         case 0: /* Bits 0-7 */
1342                 break;
1343         case 1: /* Bits 8-15 */
1344                 break;
1345         case 2: /* Bits 16-23 */
1346 #ifdef CONFIG_WNM
1347                 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */
1348                 *pos |= 0x08; /* Bit 19 - BSS Transition */
1349 #endif /* CONFIG_WNM */
1350                 break;
1351         case 3: /* Bits 24-31 */
1352 #ifdef CONFIG_WNM
1353                 *pos |= 0x02; /* Bit 25 - SSID List */
1354 #endif /* CONFIG_WNM */
1355 #ifdef CONFIG_INTERWORKING
1356                 if (wpa_s->conf->interworking)
1357                         *pos |= 0x80; /* Bit 31 - Interworking */
1358 #endif /* CONFIG_INTERWORKING */
1359                 break;
1360         case 4: /* Bits 32-39 */
1361 #ifdef CONFIG_INTERWORKING
1362                 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1363                         *pos |= 0x01; /* Bit 32 - QoS Map */
1364 #endif /* CONFIG_INTERWORKING */
1365                 break;
1366         case 5: /* Bits 40-47 */
1367 #ifdef CONFIG_HS20
1368                 if (wpa_s->conf->hs20)
1369                         *pos |= 0x40; /* Bit 46 - WNM-Notification */
1370 #endif /* CONFIG_HS20 */
1371                 break;
1372         case 6: /* Bits 48-55 */
1373                 break;
1374         }
1375 }
1376
1377
1378 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1379 {
1380         u8 *pos = buf;
1381         u8 len = 6, i;
1382
1383         if (len < wpa_s->extended_capa_len)
1384                 len = wpa_s->extended_capa_len;
1385         if (buflen < (size_t) len + 2) {
1386                 wpa_printf(MSG_INFO,
1387                            "Not enough room for building extended capabilities element");
1388                 return -1;
1389         }
1390
1391         *pos++ = WLAN_EID_EXT_CAPAB;
1392         *pos++ = len;
1393         for (i = 0; i < len; i++, pos++) {
1394                 wpas_ext_capab_byte(wpa_s, pos, i);
1395
1396                 if (i < wpa_s->extended_capa_len) {
1397                         *pos &= ~wpa_s->extended_capa_mask[i];
1398                         *pos |= wpa_s->extended_capa[i];
1399                 }
1400         }
1401
1402         while (len > 0 && buf[1 + len] == 0) {
1403                 len--;
1404                 buf[1] = len;
1405         }
1406         if (len == 0)
1407                 return 0;
1408
1409         return 2 + len;
1410 }
1411
1412
1413 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1414                           struct wpa_bss *test_bss)
1415 {
1416         struct wpa_bss *bss;
1417
1418         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1419                 if (bss == test_bss)
1420                         return 1;
1421         }
1422
1423         return 0;
1424 }
1425
1426
1427 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1428                            struct wpa_ssid *test_ssid)
1429 {
1430         struct wpa_ssid *ssid;
1431
1432         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1433                 if (ssid == test_ssid)
1434                         return 1;
1435         }
1436
1437         return 0;
1438 }
1439
1440
1441 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1442                         struct wpa_ssid *test_ssid)
1443 {
1444         if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1445                 return 0;
1446
1447         return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1448 }
1449
1450
1451 void wpas_connect_work_free(struct wpa_connect_work *cwork)
1452 {
1453         if (cwork == NULL)
1454                 return;
1455         os_free(cwork);
1456 }
1457
1458
1459 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1460 {
1461         struct wpa_connect_work *cwork;
1462         struct wpa_radio_work *work = wpa_s->connect_work;
1463
1464         if (!work)
1465                 return;
1466
1467         wpa_s->connect_work = NULL;
1468         cwork = work->ctx;
1469         work->ctx = NULL;
1470         wpas_connect_work_free(cwork);
1471         radio_work_done(work);
1472 }
1473
1474
1475 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1476 {
1477         struct os_reltime now;
1478         u8 addr[ETH_ALEN];
1479
1480         os_get_reltime(&now);
1481         if (wpa_s->last_mac_addr_style == style &&
1482             wpa_s->last_mac_addr_change.sec != 0 &&
1483             !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1484                                 wpa_s->conf->rand_addr_lifetime)) {
1485                 wpa_msg(wpa_s, MSG_DEBUG,
1486                         "Previously selected random MAC address has not yet expired");
1487                 return 0;
1488         }
1489
1490         switch (style) {
1491         case 1:
1492                 if (random_mac_addr(addr) < 0)
1493                         return -1;
1494                 break;
1495         case 2:
1496                 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1497                 if (random_mac_addr_keep_oui(addr) < 0)
1498                         return -1;
1499                 break;
1500         default:
1501                 return -1;
1502         }
1503
1504         if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1505                 wpa_msg(wpa_s, MSG_INFO,
1506                         "Failed to set random MAC address");
1507                 return -1;
1508         }
1509
1510         os_get_reltime(&wpa_s->last_mac_addr_change);
1511         wpa_s->mac_addr_changed = 1;
1512         wpa_s->last_mac_addr_style = style;
1513
1514         if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1515                 wpa_msg(wpa_s, MSG_INFO,
1516                         "Could not update MAC address information");
1517                 return -1;
1518         }
1519
1520         wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1521                 MAC2STR(addr));
1522
1523         return 0;
1524 }
1525
1526
1527 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1528 {
1529         if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1530             !wpa_s->conf->preassoc_mac_addr)
1531                 return 0;
1532
1533         return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1534 }
1535
1536
1537 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit);
1538
1539 /**
1540  * wpa_supplicant_associate - Request association
1541  * @wpa_s: Pointer to wpa_supplicant data
1542  * @bss: Scan results for the selected BSS, or %NULL if not available
1543  * @ssid: Configuration data for the selected network
1544  *
1545  * This function is used to request %wpa_supplicant to associate with a BSS.
1546  */
1547 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1548                               struct wpa_bss *bss, struct wpa_ssid *ssid)
1549 {
1550         struct wpa_connect_work *cwork;
1551         int rand_style;
1552
1553         if (ssid->mac_addr == -1)
1554                 rand_style = wpa_s->conf->mac_addr;
1555         else
1556                 rand_style = ssid->mac_addr;
1557
1558         wmm_ac_clear_saved_tspecs(wpa_s);
1559         wpa_s->reassoc_same_bss = 0;
1560
1561         if (wpa_s->last_ssid == ssid) {
1562                 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1563                 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1564                         wmm_ac_save_tspecs(wpa_s);
1565                         wpa_s->reassoc_same_bss = 1;
1566                 }
1567         } else if (rand_style > 0) {
1568                 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1569                         return;
1570                 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1571         } else if (wpa_s->mac_addr_changed) {
1572                 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1573                         wpa_msg(wpa_s, MSG_INFO,
1574                                 "Could not restore permanent MAC address");
1575                         return;
1576                 }
1577                 wpa_s->mac_addr_changed = 0;
1578                 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1579                         wpa_msg(wpa_s, MSG_INFO,
1580                                 "Could not update MAC address information");
1581                         return;
1582                 }
1583                 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1584         }
1585         wpa_s->last_ssid = ssid;
1586
1587 #ifdef CONFIG_IBSS_RSN
1588         ibss_rsn_deinit(wpa_s->ibss_rsn);
1589         wpa_s->ibss_rsn = NULL;
1590 #endif /* CONFIG_IBSS_RSN */
1591
1592         if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1593             ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1594 #ifdef CONFIG_AP
1595                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1596                         wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1597                                 "mode");
1598                         return;
1599                 }
1600                 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1601                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1602                         if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1603                                 wpas_p2p_ap_setup_failed(wpa_s);
1604                         return;
1605                 }
1606                 wpa_s->current_bss = bss;
1607 #else /* CONFIG_AP */
1608                 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1609                         "the build");
1610 #endif /* CONFIG_AP */
1611                 return;
1612         }
1613
1614         if (ssid->mode == WPAS_MODE_MESH) {
1615 #ifdef CONFIG_MESH
1616                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
1617                         wpa_msg(wpa_s, MSG_INFO,
1618                                 "Driver does not support mesh mode");
1619                         return;
1620                 }
1621                 if (bss)
1622                         ssid->frequency = bss->freq;
1623                 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
1624                         wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
1625                         return;
1626                 }
1627                 wpa_s->current_bss = bss;
1628                 wpa_msg_ctrl(wpa_s, MSG_INFO, MESH_GROUP_STARTED
1629                              "ssid=\"%s\" id=%d",
1630                              wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
1631                              ssid->id);
1632 #else /* CONFIG_MESH */
1633                 wpa_msg(wpa_s, MSG_ERROR,
1634                         "mesh mode support not included in the build");
1635 #endif /* CONFIG_MESH */
1636                 return;
1637         }
1638
1639 #ifdef CONFIG_TDLS
1640         if (bss)
1641                 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1642                                 bss->ie_len);
1643 #endif /* CONFIG_TDLS */
1644
1645         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1646             ssid->mode == IEEE80211_MODE_INFRA) {
1647                 sme_authenticate(wpa_s, bss, ssid);
1648                 return;
1649         }
1650
1651         if (wpa_s->connect_work) {
1652                 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1653                 return;
1654         }
1655
1656         if (radio_work_pending(wpa_s, "connect")) {
1657                 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1658                 return;
1659         }
1660
1661         cwork = os_zalloc(sizeof(*cwork));
1662         if (cwork == NULL)
1663                 return;
1664
1665         cwork->bss = bss;
1666         cwork->ssid = ssid;
1667
1668         if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1669                            wpas_start_assoc_cb, cwork) < 0) {
1670                 os_free(cwork);
1671         }
1672 }
1673
1674
1675 static int bss_is_ibss(struct wpa_bss *bss)
1676 {
1677         return (bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) ==
1678                 IEEE80211_CAP_IBSS;
1679 }
1680
1681
1682 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
1683                           const struct wpa_ssid *ssid,
1684                           struct hostapd_freq_params *freq)
1685 {
1686         enum hostapd_hw_mode hw_mode;
1687         struct hostapd_hw_modes *mode = NULL;
1688         int ht40plus[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1689                            184, 192 };
1690         int vht80[] = { 36, 52, 100, 116, 132, 149 };
1691         struct hostapd_channel_data *pri_chan = NULL, *sec_chan = NULL;
1692         u8 channel;
1693         int i, chan_idx, ht40 = -1, res, obss_scan = 1;
1694         unsigned int j;
1695         struct hostapd_freq_params vht_freq;
1696
1697         freq->freq = ssid->frequency;
1698
1699         for (j = 0; j < wpa_s->last_scan_res_used; j++) {
1700                 struct wpa_bss *bss = wpa_s->last_scan_res[j];
1701
1702                 if (ssid->mode != WPAS_MODE_IBSS)
1703                         break;
1704
1705                 /* Don't adjust control freq in case of fixed_freq */
1706                 if (ssid->fixed_freq)
1707                         break;
1708
1709                 if (!bss_is_ibss(bss))
1710                         continue;
1711
1712                 if (ssid->ssid_len == bss->ssid_len &&
1713                     os_memcmp(ssid->ssid, bss->ssid, bss->ssid_len) == 0) {
1714                         wpa_printf(MSG_DEBUG,
1715                                    "IBSS already found in scan results, adjust control freq: %d",
1716                                    bss->freq);
1717                         freq->freq = bss->freq;
1718                         obss_scan = 0;
1719                         break;
1720                 }
1721         }
1722
1723         /* For IBSS check HT_IBSS flag */
1724         if (ssid->mode == WPAS_MODE_IBSS &&
1725             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
1726                 return;
1727
1728         if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
1729             wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
1730             wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
1731                 wpa_printf(MSG_DEBUG,
1732                            "IBSS: WEP/TKIP detected, do not try to enable HT");
1733                 return;
1734         }
1735
1736         hw_mode = ieee80211_freq_to_chan(freq->freq, &channel);
1737         for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1738                 if (wpa_s->hw.modes[i].mode == hw_mode) {
1739                         mode = &wpa_s->hw.modes[i];
1740                         break;
1741                 }
1742         }
1743
1744         if (!mode)
1745                 return;
1746
1747         freq->ht_enabled = ht_supported(mode);
1748         if (!freq->ht_enabled)
1749                 return;
1750
1751         /* Setup higher BW only for 5 GHz */
1752         if (mode->mode != HOSTAPD_MODE_IEEE80211A)
1753                 return;
1754
1755         for (chan_idx = 0; chan_idx < mode->num_channels; chan_idx++) {
1756                 pri_chan = &mode->channels[chan_idx];
1757                 if (pri_chan->chan == channel)
1758                         break;
1759                 pri_chan = NULL;
1760         }
1761         if (!pri_chan)
1762                 return;
1763
1764         /* Check primary channel flags */
1765         if (pri_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1766                 return;
1767
1768         /* Check/setup HT40+/HT40- */
1769         for (j = 0; j < ARRAY_SIZE(ht40plus); j++) {
1770                 if (ht40plus[j] == channel) {
1771                         ht40 = 1;
1772                         break;
1773                 }
1774         }
1775
1776         /* Find secondary channel */
1777         for (i = 0; i < mode->num_channels; i++) {
1778                 sec_chan = &mode->channels[i];
1779                 if (sec_chan->chan == channel + ht40 * 4)
1780                         break;
1781                 sec_chan = NULL;
1782         }
1783         if (!sec_chan)
1784                 return;
1785
1786         /* Check secondary channel flags */
1787         if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1788                 return;
1789
1790         freq->channel = pri_chan->chan;
1791
1792         switch (ht40) {
1793         case -1:
1794                 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS))
1795                         return;
1796                 freq->sec_channel_offset = -1;
1797                 break;
1798         case 1:
1799                 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS))
1800                         return;
1801                 freq->sec_channel_offset = 1;
1802                 break;
1803         default:
1804                 break;
1805         }
1806
1807         if (freq->sec_channel_offset && obss_scan) {
1808                 struct wpa_scan_results *scan_res;
1809
1810                 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
1811                 if (scan_res == NULL) {
1812                         /* Back to HT20 */
1813                         freq->sec_channel_offset = 0;
1814                         return;
1815                 }
1816
1817                 res = check_40mhz_5g(mode, scan_res, pri_chan->chan,
1818                                      sec_chan->chan);
1819                 switch (res) {
1820                 case 0:
1821                         /* Back to HT20 */
1822                         freq->sec_channel_offset = 0;
1823                         break;
1824                 case 1:
1825                         /* Configuration allowed */
1826                         break;
1827                 case 2:
1828                         /* Switch pri/sec channels */
1829                         freq->freq = hw_get_freq(mode, sec_chan->chan);
1830                         freq->sec_channel_offset = -freq->sec_channel_offset;
1831                         freq->channel = sec_chan->chan;
1832                         break;
1833                 default:
1834                         freq->sec_channel_offset = 0;
1835                         break;
1836                 }
1837
1838                 wpa_scan_results_free(scan_res);
1839         }
1840
1841         wpa_printf(MSG_DEBUG,
1842                    "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
1843                    freq->channel, freq->sec_channel_offset);
1844
1845         /* Not sure if mesh is ready for VHT */
1846         if (ssid->mode != WPAS_MODE_IBSS)
1847                 return;
1848
1849         /* For IBSS check VHT_IBSS flag */
1850         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
1851                 return;
1852
1853         vht_freq = *freq;
1854
1855         vht_freq.vht_enabled = vht_supported(mode);
1856         if (!vht_freq.vht_enabled)
1857                 return;
1858
1859         /* setup center_freq1, bandwidth */
1860         for (j = 0; j < ARRAY_SIZE(vht80); j++) {
1861                 if (freq->channel >= vht80[j] &&
1862                     freq->channel < vht80[j] + 16)
1863                         break;
1864         }
1865
1866         if (j == ARRAY_SIZE(vht80))
1867                 return;
1868
1869         for (i = vht80[j]; i < vht80[j] + 16; i += 4) {
1870                 struct hostapd_channel_data *chan;
1871
1872                 chan = hw_get_channel_chan(mode, i, NULL);
1873                 if (!chan)
1874                         return;
1875
1876                 /* Back to HT configuration if channel not usable */
1877                 if (chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1878                         return;
1879         }
1880
1881         if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq,
1882                                     freq->channel, freq->ht_enabled,
1883                                     vht_freq.vht_enabled,
1884                                     freq->sec_channel_offset,
1885                                     VHT_CHANWIDTH_80MHZ,
1886                                     vht80[j] + 6, 0, 0) != 0)
1887                 return;
1888
1889         *freq = vht_freq;
1890
1891         wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
1892                    freq->center_freq1, freq->center_freq2, freq->bandwidth);
1893 }
1894
1895
1896 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
1897 {
1898         struct wpa_connect_work *cwork = work->ctx;
1899         struct wpa_bss *bss = cwork->bss;
1900         struct wpa_ssid *ssid = cwork->ssid;
1901         struct wpa_supplicant *wpa_s = work->wpa_s;
1902         u8 wpa_ie[200];
1903         size_t wpa_ie_len;
1904         int use_crypt, ret, i, bssid_changed;
1905         int algs = WPA_AUTH_ALG_OPEN;
1906         unsigned int cipher_pairwise, cipher_group;
1907         struct wpa_driver_associate_params params;
1908         int wep_keys_set = 0;
1909         int assoc_failed = 0;
1910         struct wpa_ssid *old_ssid;
1911 #ifdef CONFIG_HT_OVERRIDES
1912         struct ieee80211_ht_capabilities htcaps;
1913         struct ieee80211_ht_capabilities htcaps_mask;
1914 #endif /* CONFIG_HT_OVERRIDES */
1915 #ifdef CONFIG_VHT_OVERRIDES
1916        struct ieee80211_vht_capabilities vhtcaps;
1917        struct ieee80211_vht_capabilities vhtcaps_mask;
1918 #endif /* CONFIG_VHT_OVERRIDES */
1919
1920         if (deinit) {
1921                 if (work->started) {
1922                         wpa_s->connect_work = NULL;
1923
1924                         /* cancel possible auth. timeout */
1925                         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
1926                                              NULL);
1927                 }
1928                 wpas_connect_work_free(cwork);
1929                 return;
1930         }
1931
1932         wpa_s->connect_work = work;
1933
1934         if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid)) {
1935                 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
1936                 wpas_connect_work_done(wpa_s);
1937                 return;
1938         }
1939
1940         os_memset(&params, 0, sizeof(params));
1941         wpa_s->reassociate = 0;
1942         wpa_s->eap_expected_failure = 0;
1943         if (bss &&
1944             (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
1945 #ifdef CONFIG_IEEE80211R
1946                 const u8 *ie, *md = NULL;
1947 #endif /* CONFIG_IEEE80211R */
1948                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1949                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1950                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1951                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1952                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1953                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1954                 if (bssid_changed)
1955                         wpas_notify_bssid_changed(wpa_s);
1956 #ifdef CONFIG_IEEE80211R
1957                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1958                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1959                         md = ie + 2;
1960                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1961                 if (md) {
1962                         /* Prepare for the next transition */
1963                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1964                 }
1965 #endif /* CONFIG_IEEE80211R */
1966 #ifdef CONFIG_WPS
1967         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1968                    wpa_s->conf->ap_scan == 2 &&
1969                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1970                 /* Use ap_scan==1 style network selection to find the network
1971                  */
1972                 wpas_connect_work_done(wpa_s);
1973                 wpa_s->scan_req = MANUAL_SCAN_REQ;
1974                 wpa_s->reassociate = 1;
1975                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1976                 return;
1977 #endif /* CONFIG_WPS */
1978         } else {
1979                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1980                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1981                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1982         }
1983         wpa_supplicant_cancel_sched_scan(wpa_s);
1984         wpa_supplicant_cancel_scan(wpa_s);
1985
1986         /* Starting new association, so clear the possibly used WPA IE from the
1987          * previous association. */
1988         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1989
1990 #ifdef IEEE8021X_EAPOL
1991         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1992                 if (ssid->leap) {
1993                         if (ssid->non_leap == 0)
1994                                 algs = WPA_AUTH_ALG_LEAP;
1995                         else
1996                                 algs |= WPA_AUTH_ALG_LEAP;
1997                 }
1998         }
1999 #endif /* IEEE8021X_EAPOL */
2000         wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2001         if (ssid->auth_alg) {
2002                 algs = ssid->auth_alg;
2003                 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
2004                         "0x%x", algs);
2005         }
2006
2007         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
2008                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
2009             wpa_key_mgmt_wpa(ssid->key_mgmt)) {
2010                 int try_opportunistic;
2011                 try_opportunistic = (ssid->proactive_key_caching < 0 ?
2012                                      wpa_s->conf->okc :
2013                                      ssid->proactive_key_caching) &&
2014                         (ssid->proto & WPA_PROTO_RSN);
2015                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2016                                             ssid, try_opportunistic) == 0)
2017                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2018                 wpa_ie_len = sizeof(wpa_ie);
2019                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2020                                               wpa_ie, &wpa_ie_len)) {
2021                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2022                                 "key management and encryption suites");
2023                         wpas_connect_work_done(wpa_s);
2024                         return;
2025                 }
2026         } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
2027                    wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
2028                 /*
2029                  * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2030                  * use non-WPA since the scan results did not indicate that the
2031                  * AP is using WPA or WPA2.
2032                  */
2033                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2034                 wpa_ie_len = 0;
2035                 wpa_s->wpa_proto = 0;
2036         } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
2037                 wpa_ie_len = sizeof(wpa_ie);
2038                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2039                                               wpa_ie, &wpa_ie_len)) {
2040                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2041                                 "key management and encryption suites (no "
2042                                 "scan results)");
2043                         wpas_connect_work_done(wpa_s);
2044                         return;
2045                 }
2046 #ifdef CONFIG_WPS
2047         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
2048                 struct wpabuf *wps_ie;
2049                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
2050                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
2051                         wpa_ie_len = wpabuf_len(wps_ie);
2052                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
2053                 } else
2054                         wpa_ie_len = 0;
2055                 wpabuf_free(wps_ie);
2056                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2057                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
2058                         params.wps = WPS_MODE_PRIVACY;
2059                 else
2060                         params.wps = WPS_MODE_OPEN;
2061                 wpa_s->wpa_proto = 0;
2062 #endif /* CONFIG_WPS */
2063         } else {
2064                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2065                 wpa_ie_len = 0;
2066                 wpa_s->wpa_proto = 0;
2067         }
2068
2069 #ifdef CONFIG_P2P
2070         if (wpa_s->global->p2p) {
2071                 u8 *pos;
2072                 size_t len;
2073                 int res;
2074                 pos = wpa_ie + wpa_ie_len;
2075                 len = sizeof(wpa_ie) - wpa_ie_len;
2076                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2077                                             ssid->p2p_group);
2078                 if (res >= 0)
2079                         wpa_ie_len += res;
2080         }
2081
2082         wpa_s->cross_connect_disallowed = 0;
2083         if (bss) {
2084                 struct wpabuf *p2p;
2085                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
2086                 if (p2p) {
2087                         wpa_s->cross_connect_disallowed =
2088                                 p2p_get_cross_connect_disallowed(p2p);
2089                         wpabuf_free(p2p);
2090                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2091                                 "connection",
2092                                 wpa_s->cross_connect_disallowed ?
2093                                 "disallows" : "allows");
2094                 }
2095         }
2096
2097         os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2098 #endif /* CONFIG_P2P */
2099
2100 #ifdef CONFIG_HS20
2101         if (is_hs20_network(wpa_s, ssid, bss)) {
2102                 struct wpabuf *hs20;
2103                 hs20 = wpabuf_alloc(20);
2104                 if (hs20) {
2105                         int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2106                         size_t len;
2107
2108                         wpas_hs20_add_indication(hs20, pps_mo_id);
2109                         len = sizeof(wpa_ie) - wpa_ie_len;
2110                         if (wpabuf_len(hs20) <= len) {
2111                                 os_memcpy(wpa_ie + wpa_ie_len,
2112                                           wpabuf_head(hs20), wpabuf_len(hs20));
2113                                 wpa_ie_len += wpabuf_len(hs20);
2114                         }
2115                         wpabuf_free(hs20);
2116                 }
2117         }
2118 #endif /* CONFIG_HS20 */
2119
2120         /*
2121          * Workaround: Add Extended Capabilities element only if the AP
2122          * included this element in Beacon/Probe Response frames. Some older
2123          * APs seem to have interoperability issues if this element is
2124          * included, so while the standard may require us to include the
2125          * element in all cases, it is justifiable to skip it to avoid
2126          * interoperability issues.
2127          */
2128         if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
2129                 u8 ext_capab[18];
2130                 int ext_capab_len;
2131                 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2132                                                      sizeof(ext_capab));
2133                 if (ext_capab_len > 0) {
2134                         u8 *pos = wpa_ie;
2135                         if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
2136                                 pos += 2 + pos[1];
2137                         os_memmove(pos + ext_capab_len, pos,
2138                                    wpa_ie_len - (pos - wpa_ie));
2139                         wpa_ie_len += ext_capab_len;
2140                         os_memcpy(pos, ext_capab, ext_capab_len);
2141                 }
2142         }
2143
2144         if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2145                 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2146                 size_t len;
2147
2148                 len = sizeof(wpa_ie) - wpa_ie_len;
2149                 if (wpabuf_len(buf) <= len) {
2150                         os_memcpy(wpa_ie + wpa_ie_len,
2151                                   wpabuf_head(buf), wpabuf_len(buf));
2152                         wpa_ie_len += wpabuf_len(buf);
2153                 }
2154         }
2155
2156         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2157         use_crypt = 1;
2158         cipher_pairwise = wpa_s->pairwise_cipher;
2159         cipher_group = wpa_s->group_cipher;
2160         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2161             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2162                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2163                         use_crypt = 0;
2164                 if (wpa_set_wep_keys(wpa_s, ssid)) {
2165                         use_crypt = 1;
2166                         wep_keys_set = 1;
2167                 }
2168         }
2169         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2170                 use_crypt = 0;
2171
2172 #ifdef IEEE8021X_EAPOL
2173         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2174                 if ((ssid->eapol_flags &
2175                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
2176                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
2177                     !wep_keys_set) {
2178                         use_crypt = 0;
2179                 } else {
2180                         /* Assume that dynamic WEP-104 keys will be used and
2181                          * set cipher suites in order for drivers to expect
2182                          * encryption. */
2183                         cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
2184                 }
2185         }
2186 #endif /* IEEE8021X_EAPOL */
2187
2188         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2189                 /* Set the key before (and later after) association */
2190                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2191         }
2192
2193         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2194         if (bss) {
2195                 params.ssid = bss->ssid;
2196                 params.ssid_len = bss->ssid_len;
2197                 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2198                         wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
2199                                    MACSTR " freq=%u MHz based on scan results "
2200                                    "(bssid_set=%d)",
2201                                    MAC2STR(bss->bssid), bss->freq,
2202                                    ssid->bssid_set);
2203                         params.bssid = bss->bssid;
2204                         params.freq.freq = bss->freq;
2205                 }
2206                 params.bssid_hint = bss->bssid;
2207                 params.freq_hint = bss->freq;
2208         } else {
2209                 params.ssid = ssid->ssid;
2210                 params.ssid_len = ssid->ssid_len;
2211         }
2212
2213         if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
2214             wpa_s->conf->ap_scan == 2) {
2215                 params.bssid = ssid->bssid;
2216                 params.fixed_bssid = 1;
2217         }
2218
2219         /* Initial frequency for IBSS/mesh */
2220         if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) &&
2221             ssid->frequency > 0 && params.freq.freq == 0)
2222                 ibss_mesh_setup_freq(wpa_s, ssid, &params.freq);
2223
2224         if (ssid->mode == WPAS_MODE_IBSS) {
2225                 params.fixed_freq = ssid->fixed_freq;
2226                 if (ssid->beacon_int)
2227                         params.beacon_int = ssid->beacon_int;
2228                 else
2229                         params.beacon_int = wpa_s->conf->beacon_int;
2230         }
2231
2232         params.wpa_ie = wpa_ie;
2233         params.wpa_ie_len = wpa_ie_len;
2234         params.pairwise_suite = cipher_pairwise;
2235         params.group_suite = cipher_group;
2236         params.key_mgmt_suite = wpa_s->key_mgmt;
2237         params.wpa_proto = wpa_s->wpa_proto;
2238         params.auth_alg = algs;
2239         params.mode = ssid->mode;
2240         params.bg_scan_period = ssid->bg_scan_period;
2241         for (i = 0; i < NUM_WEP_KEYS; i++) {
2242                 if (ssid->wep_key_len[i])
2243                         params.wep_key[i] = ssid->wep_key[i];
2244                 params.wep_key_len[i] = ssid->wep_key_len[i];
2245         }
2246         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
2247
2248         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2249             (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2250              params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
2251                 params.passphrase = ssid->passphrase;
2252                 if (ssid->psk_set)
2253                         params.psk = ssid->psk;
2254         }
2255
2256         if (wpa_s->conf->key_mgmt_offload) {
2257                 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
2258                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
2259                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
2260                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
2261                         params.req_key_mgmt_offload =
2262                                 ssid->proactive_key_caching < 0 ?
2263                                 wpa_s->conf->okc : ssid->proactive_key_caching;
2264                 else
2265                         params.req_key_mgmt_offload = 1;
2266
2267                 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2268                      params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
2269                      params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
2270                     ssid->psk_set)
2271                         params.psk = ssid->psk;
2272         }
2273
2274         params.drop_unencrypted = use_crypt;
2275
2276 #ifdef CONFIG_IEEE80211W
2277         params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
2278         if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
2279                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2280                 struct wpa_ie_data ie;
2281                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
2282                     ie.capabilities &
2283                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
2284                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2285                                 "MFP: require MFP");
2286                         params.mgmt_frame_protection =
2287                                 MGMT_FRAME_PROTECTION_REQUIRED;
2288                 }
2289         }
2290 #endif /* CONFIG_IEEE80211W */
2291
2292         params.p2p = ssid->p2p_group;
2293
2294         if (wpa_s->parent->set_sta_uapsd)
2295                 params.uapsd = wpa_s->parent->sta_uapsd;
2296         else
2297                 params.uapsd = -1;
2298
2299 #ifdef CONFIG_HT_OVERRIDES
2300         os_memset(&htcaps, 0, sizeof(htcaps));
2301         os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
2302         params.htcaps = (u8 *) &htcaps;
2303         params.htcaps_mask = (u8 *) &htcaps_mask;
2304         wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
2305 #endif /* CONFIG_HT_OVERRIDES */
2306 #ifdef CONFIG_VHT_OVERRIDES
2307         os_memset(&vhtcaps, 0, sizeof(vhtcaps));
2308         os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
2309         params.vhtcaps = &vhtcaps;
2310         params.vhtcaps_mask = &vhtcaps_mask;
2311         wpa_supplicant_apply_vht_overrides(wpa_s, ssid, &params);
2312 #endif /* CONFIG_VHT_OVERRIDES */
2313
2314 #ifdef CONFIG_P2P
2315         /*
2316          * If multi-channel concurrency is not supported, check for any
2317          * frequency conflict. In case of any frequency conflict, remove the
2318          * least prioritized connection.
2319          */
2320         if (wpa_s->num_multichan_concurrent < 2) {
2321                 int freq, num;
2322                 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2323                 if (num > 0 && freq > 0 && freq != params.freq.freq) {
2324                         wpa_printf(MSG_DEBUG,
2325                                    "Assoc conflicting freq found (%d != %d)",
2326                                    freq, params.freq.freq);
2327                         if (wpas_p2p_handle_frequency_conflicts(
2328                                     wpa_s, params.freq.freq, ssid) < 0) {
2329                                 wpas_connect_work_done(wpa_s);
2330                                 return;
2331                         }
2332                 }
2333         }
2334 #endif /* CONFIG_P2P */
2335
2336         ret = wpa_drv_associate(wpa_s, &params);
2337         if (ret < 0) {
2338                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2339                         "failed");
2340                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2341                         /*
2342                          * The driver is known to mean what is saying, so we
2343                          * can stop right here; the association will not
2344                          * succeed.
2345                          */
2346                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2347                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2348                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2349                         return;
2350                 }
2351                 /* try to continue anyway; new association will be tried again
2352                  * after timeout */
2353                 assoc_failed = 1;
2354         }
2355
2356         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2357                 /* Set the key after the association just in case association
2358                  * cleared the previously configured key. */
2359                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2360                 /* No need to timeout authentication since there is no key
2361                  * management. */
2362                 wpa_supplicant_cancel_auth_timeout(wpa_s);
2363                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2364 #ifdef CONFIG_IBSS_RSN
2365         } else if (ssid->mode == WPAS_MODE_IBSS &&
2366                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2367                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2368                 /*
2369                  * RSN IBSS authentication is per-STA and we can disable the
2370                  * per-BSSID authentication.
2371                  */
2372                 wpa_supplicant_cancel_auth_timeout(wpa_s);
2373 #endif /* CONFIG_IBSS_RSN */
2374         } else {
2375                 /* Timeout for IEEE 802.11 authentication and association */
2376                 int timeout = 60;
2377
2378                 if (assoc_failed) {
2379                         /* give IBSS a bit more time */
2380                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2381                 } else if (wpa_s->conf->ap_scan == 1) {
2382                         /* give IBSS a bit more time */
2383                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2384                 }
2385                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2386         }
2387
2388         if (wep_keys_set &&
2389             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2390                 /* Set static WEP keys again */
2391                 wpa_set_wep_keys(wpa_s, ssid);
2392         }
2393
2394         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2395                 /*
2396                  * Do not allow EAP session resumption between different
2397                  * network configurations.
2398                  */
2399                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2400         }
2401         old_ssid = wpa_s->current_ssid;
2402         wpa_s->current_ssid = ssid;
2403         if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set)
2404                 wpa_s->current_bss = bss;
2405         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2406         wpa_supplicant_initiate_eapol(wpa_s);
2407         if (old_ssid != wpa_s->current_ssid)
2408                 wpas_notify_network_changed(wpa_s);
2409 }
2410
2411
2412 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2413                                             const u8 *addr)
2414 {
2415         struct wpa_ssid *old_ssid;
2416
2417         wpas_connect_work_done(wpa_s);
2418         wpa_clear_keys(wpa_s, addr);
2419         old_ssid = wpa_s->current_ssid;
2420         wpa_supplicant_mark_disassoc(wpa_s);
2421         wpa_sm_set_config(wpa_s->wpa, NULL);
2422         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2423         if (old_ssid != wpa_s->current_ssid)
2424                 wpas_notify_network_changed(wpa_s);
2425         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2426 }
2427
2428
2429 /**
2430  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2431  * @wpa_s: Pointer to wpa_supplicant data
2432  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2433  *
2434  * This function is used to request %wpa_supplicant to deauthenticate from the
2435  * current AP.
2436  */
2437 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2438                                    int reason_code)
2439 {
2440         u8 *addr = NULL;
2441         union wpa_event_data event;
2442         int zero_addr = 0;
2443
2444         wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2445                 " pending_bssid=" MACSTR " reason=%d state=%s",
2446                 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2447                 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2448
2449         if (!is_zero_ether_addr(wpa_s->bssid))
2450                 addr = wpa_s->bssid;
2451         else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2452                  (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2453                   wpa_s->wpa_state == WPA_ASSOCIATING))
2454                 addr = wpa_s->pending_bssid;
2455         else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2456                 /*
2457                  * When using driver-based BSS selection, we may not know the
2458                  * BSSID with which we are currently trying to associate. We
2459                  * need to notify the driver of this disconnection even in such
2460                  * a case, so use the all zeros address here.
2461                  */
2462                 addr = wpa_s->bssid;
2463                 zero_addr = 1;
2464         }
2465
2466 #ifdef CONFIG_TDLS
2467         wpa_tdls_teardown_peers(wpa_s->wpa);
2468 #endif /* CONFIG_TDLS */
2469
2470 #ifdef CONFIG_MESH
2471         if (wpa_s->ifmsh) {
2472                 wpa_msg_ctrl(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
2473                              wpa_s->ifname);
2474                 wpa_supplicant_leave_mesh(wpa_s);
2475         }
2476 #endif /* CONFIG_MESH */
2477
2478         if (addr) {
2479                 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2480                 os_memset(&event, 0, sizeof(event));
2481                 event.deauth_info.reason_code = (u16) reason_code;
2482                 event.deauth_info.locally_generated = 1;
2483                 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2484                 if (zero_addr)
2485                         addr = NULL;
2486         }
2487
2488         wpa_supplicant_clear_connection(wpa_s, addr);
2489 }
2490
2491 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2492                                               struct wpa_ssid *ssid)
2493 {
2494         if (!ssid || !ssid->disabled || ssid->disabled == 2)
2495                 return;
2496
2497         ssid->disabled = 0;
2498         wpas_clear_temp_disabled(wpa_s, ssid, 1);
2499         wpas_notify_network_enabled_changed(wpa_s, ssid);
2500
2501         /*
2502          * Try to reassociate since there is no current configuration and a new
2503          * network was made available.
2504          */
2505         if (!wpa_s->current_ssid && !wpa_s->disconnected)
2506                 wpa_s->reassociate = 1;
2507 }
2508
2509
2510 /**
2511  * wpa_supplicant_enable_network - Mark a configured network as enabled
2512  * @wpa_s: wpa_supplicant structure for a network interface
2513  * @ssid: wpa_ssid structure for a configured network or %NULL
2514  *
2515  * Enables the specified network or all networks if no network specified.
2516  */
2517 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2518                                    struct wpa_ssid *ssid)
2519 {
2520         if (ssid == NULL) {
2521                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2522                         wpa_supplicant_enable_one_network(wpa_s, ssid);
2523         } else
2524                 wpa_supplicant_enable_one_network(wpa_s, ssid);
2525
2526         if (wpa_s->reassociate && !wpa_s->disconnected) {
2527                 if (wpa_s->sched_scanning) {
2528                         wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2529                                    "new network to scan filters");
2530                         wpa_supplicant_cancel_sched_scan(wpa_s);
2531                 }
2532
2533                 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2534                         wpa_supplicant_req_scan(wpa_s, 0, 0);
2535         }
2536 }
2537
2538
2539 /**
2540  * wpa_supplicant_disable_network - Mark a configured network as disabled
2541  * @wpa_s: wpa_supplicant structure for a network interface
2542  * @ssid: wpa_ssid structure for a configured network or %NULL
2543  *
2544  * Disables the specified network or all networks if no network specified.
2545  */
2546 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2547                                     struct wpa_ssid *ssid)
2548 {
2549         struct wpa_ssid *other_ssid;
2550         int was_disabled;
2551
2552         if (ssid == NULL) {
2553                 if (wpa_s->sched_scanning)
2554                         wpa_supplicant_cancel_sched_scan(wpa_s);
2555
2556                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2557                      other_ssid = other_ssid->next) {
2558                         was_disabled = other_ssid->disabled;
2559                         if (was_disabled == 2)
2560                                 continue; /* do not change persistent P2P group
2561                                            * data */
2562
2563                         other_ssid->disabled = 1;
2564
2565                         if (was_disabled != other_ssid->disabled)
2566                                 wpas_notify_network_enabled_changed(
2567                                         wpa_s, other_ssid);
2568                 }
2569                 if (wpa_s->current_ssid)
2570                         wpa_supplicant_deauthenticate(
2571                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2572         } else if (ssid->disabled != 2) {
2573                 if (ssid == wpa_s->current_ssid)
2574                         wpa_supplicant_deauthenticate(
2575                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2576
2577                 was_disabled = ssid->disabled;
2578
2579                 ssid->disabled = 1;
2580
2581                 if (was_disabled != ssid->disabled) {
2582                         wpas_notify_network_enabled_changed(wpa_s, ssid);
2583                         if (wpa_s->sched_scanning) {
2584                                 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2585                                            "to remove network from filters");
2586                                 wpa_supplicant_cancel_sched_scan(wpa_s);
2587                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
2588                         }
2589                 }
2590         }
2591 }
2592
2593
2594 /**
2595  * wpa_supplicant_select_network - Attempt association with a network
2596  * @wpa_s: wpa_supplicant structure for a network interface
2597  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2598  */
2599 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2600                                    struct wpa_ssid *ssid)
2601 {
2602
2603         struct wpa_ssid *other_ssid;
2604         int disconnected = 0;
2605
2606         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2607                 wpa_s->own_disconnect_req = 1;
2608                 wpa_supplicant_deauthenticate(
2609                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2610                 disconnected = 1;
2611         }
2612
2613         if (ssid)
2614                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2615
2616         /*
2617          * Mark all other networks disabled or mark all networks enabled if no
2618          * network specified.
2619          */
2620         for (other_ssid = wpa_s->conf->ssid; other_ssid;
2621              other_ssid = other_ssid->next) {
2622                 int was_disabled = other_ssid->disabled;
2623                 if (was_disabled == 2)
2624                         continue; /* do not change persistent P2P group data */
2625
2626                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
2627                 if (was_disabled && !other_ssid->disabled)
2628                         wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2629
2630                 if (was_disabled != other_ssid->disabled)
2631                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2632         }
2633
2634         if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
2635                 /* We are already associated with the selected network */
2636                 wpa_printf(MSG_DEBUG, "Already associated with the "
2637                            "selected network - do nothing");
2638                 return;
2639         }
2640
2641         if (ssid) {
2642                 wpa_s->current_ssid = ssid;
2643                 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2644                 wpa_s->connect_without_scan =
2645                         (ssid->mode == WPAS_MODE_MESH) ? ssid : NULL;
2646
2647                 /*
2648                  * Don't optimize next scan freqs since a new ESS has been
2649                  * selected.
2650                  */
2651                 os_free(wpa_s->next_scan_freqs);
2652                 wpa_s->next_scan_freqs = NULL;
2653         } else {
2654                 wpa_s->connect_without_scan = NULL;
2655         }
2656
2657         wpa_s->disconnected = 0;
2658         wpa_s->reassociate = 1;
2659
2660         if (wpa_s->connect_without_scan ||
2661             wpa_supplicant_fast_associate(wpa_s) != 1)
2662                 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
2663
2664         if (ssid)
2665                 wpas_notify_network_selected(wpa_s, ssid);
2666 }
2667
2668
2669 /**
2670  * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
2671  * @wpa_s: wpa_supplicant structure for a network interface
2672  * @pkcs11_engine_path: PKCS #11 engine path or NULL
2673  * @pkcs11_module_path: PKCS #11 module path or NULL
2674  * Returns: 0 on success; -1 on failure
2675  *
2676  * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
2677  * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
2678  * module path fails the paths will be reset to the default value (NULL).
2679  */
2680 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2681                                            const char *pkcs11_engine_path,
2682                                            const char *pkcs11_module_path)
2683 {
2684         char *pkcs11_engine_path_copy = NULL;
2685         char *pkcs11_module_path_copy = NULL;
2686
2687         if (pkcs11_engine_path != NULL) {
2688                 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
2689                 if (pkcs11_engine_path_copy == NULL)
2690                         return -1;
2691         }
2692         if (pkcs11_module_path != NULL) {
2693                 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
2694                 if (pkcs11_module_path_copy == NULL) {
2695                         os_free(pkcs11_engine_path_copy);
2696                         return -1;
2697                 }
2698         }
2699
2700         os_free(wpa_s->conf->pkcs11_engine_path);
2701         os_free(wpa_s->conf->pkcs11_module_path);
2702         wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2703         wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2704
2705         wpa_sm_set_eapol(wpa_s->wpa, NULL);
2706         eapol_sm_deinit(wpa_s->eapol);
2707         wpa_s->eapol = NULL;
2708         if (wpa_supplicant_init_eapol(wpa_s)) {
2709                 /* Error -> Reset paths to the default value (NULL) once. */
2710                 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
2711                         wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2712                                                                NULL);
2713
2714                 return -1;
2715         }
2716         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2717
2718         return 0;
2719 }
2720
2721
2722 /**
2723  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2724  * @wpa_s: wpa_supplicant structure for a network interface
2725  * @ap_scan: AP scan mode
2726  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2727  *
2728  */
2729 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2730 {
2731
2732         int old_ap_scan;
2733
2734         if (ap_scan < 0 || ap_scan > 2)
2735                 return -1;
2736
2737 #ifdef ANDROID
2738         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2739             wpa_s->wpa_state >= WPA_ASSOCIATING &&
2740             wpa_s->wpa_state < WPA_COMPLETED) {
2741                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
2742                            "associating", wpa_s->conf->ap_scan, ap_scan);
2743                 return 0;
2744         }
2745 #endif /* ANDROID */
2746
2747         old_ap_scan = wpa_s->conf->ap_scan;
2748         wpa_s->conf->ap_scan = ap_scan;
2749
2750         if (old_ap_scan != wpa_s->conf->ap_scan)
2751                 wpas_notify_ap_scan_changed(wpa_s);
2752
2753         return 0;
2754 }
2755
2756
2757 /**
2758  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
2759  * @wpa_s: wpa_supplicant structure for a network interface
2760  * @expire_age: Expiration age in seconds
2761  * Returns: 0 if succeed or -1 if expire_age has an invalid value
2762  *
2763  */
2764 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2765                                           unsigned int bss_expire_age)
2766 {
2767         if (bss_expire_age < 10) {
2768                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2769                         bss_expire_age);
2770                 return -1;
2771         }
2772         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2773                 bss_expire_age);
2774         wpa_s->conf->bss_expiration_age = bss_expire_age;
2775
2776         return 0;
2777 }
2778
2779
2780 /**
2781  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
2782  * @wpa_s: wpa_supplicant structure for a network interface
2783  * @expire_count: number of scans after which an unseen BSS is reclaimed
2784  * Returns: 0 if succeed or -1 if expire_count has an invalid value
2785  *
2786  */
2787 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2788                                             unsigned int bss_expire_count)
2789 {
2790         if (bss_expire_count < 1) {
2791                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2792                         bss_expire_count);
2793                 return -1;
2794         }
2795         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2796                 bss_expire_count);
2797         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2798
2799         return 0;
2800 }
2801
2802
2803 /**
2804  * wpa_supplicant_set_scan_interval - Set scan interval
2805  * @wpa_s: wpa_supplicant structure for a network interface
2806  * @scan_interval: scan interval in seconds
2807  * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2808  *
2809  */
2810 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2811                                      int scan_interval)
2812 {
2813         if (scan_interval < 0) {
2814                 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2815                         scan_interval);
2816                 return -1;
2817         }
2818         wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2819                 scan_interval);
2820         wpa_supplicant_update_scan_int(wpa_s, scan_interval);
2821
2822         return 0;
2823 }
2824
2825
2826 /**
2827  * wpa_supplicant_set_debug_params - Set global debug params
2828  * @global: wpa_global structure
2829  * @debug_level: debug level
2830  * @debug_timestamp: determines if show timestamp in debug data
2831  * @debug_show_keys: determines if show keys in debug data
2832  * Returns: 0 if succeed or -1 if debug_level has wrong value
2833  */
2834 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
2835                                     int debug_timestamp, int debug_show_keys)
2836 {
2837
2838         int old_level, old_timestamp, old_show_keys;
2839
2840         /* check for allowed debuglevels */
2841         if (debug_level != MSG_EXCESSIVE &&
2842             debug_level != MSG_MSGDUMP &&
2843             debug_level != MSG_DEBUG &&
2844             debug_level != MSG_INFO &&
2845             debug_level != MSG_WARNING &&
2846             debug_level != MSG_ERROR)
2847                 return -1;
2848
2849         old_level = wpa_debug_level;
2850         old_timestamp = wpa_debug_timestamp;
2851         old_show_keys = wpa_debug_show_keys;
2852
2853         wpa_debug_level = debug_level;
2854         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2855         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2856
2857         if (wpa_debug_level != old_level)
2858                 wpas_notify_debug_level_changed(global);
2859         if (wpa_debug_timestamp != old_timestamp)
2860                 wpas_notify_debug_timestamp_changed(global);
2861         if (wpa_debug_show_keys != old_show_keys)
2862                 wpas_notify_debug_show_keys_changed(global);
2863
2864         return 0;
2865 }
2866
2867
2868 /**
2869  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2870  * @wpa_s: Pointer to wpa_supplicant data
2871  * Returns: A pointer to the current network structure or %NULL on failure
2872  */
2873 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2874 {
2875         struct wpa_ssid *entry;
2876         u8 ssid[SSID_MAX_LEN];
2877         int res;
2878         size_t ssid_len;
2879         u8 bssid[ETH_ALEN];
2880         int wired;
2881
2882         res = wpa_drv_get_ssid(wpa_s, ssid);
2883         if (res < 0) {
2884                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2885                         "driver");
2886                 return NULL;
2887         }
2888         ssid_len = res;
2889
2890         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2891                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2892                         "driver");
2893                 return NULL;
2894         }
2895
2896         wired = wpa_s->conf->ap_scan == 0 &&
2897                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2898
2899         entry = wpa_s->conf->ssid;
2900         while (entry) {
2901                 if (!wpas_network_disabled(wpa_s, entry) &&
2902                     ((ssid_len == entry->ssid_len &&
2903                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2904                     (!entry->bssid_set ||
2905                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2906                         return entry;
2907 #ifdef CONFIG_WPS
2908                 if (!wpas_network_disabled(wpa_s, entry) &&
2909                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2910                     (entry->ssid == NULL || entry->ssid_len == 0) &&
2911                     (!entry->bssid_set ||
2912                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2913                         return entry;
2914 #endif /* CONFIG_WPS */
2915
2916                 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2917                     entry->ssid_len == 0 &&
2918                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2919                         return entry;
2920
2921                 entry = entry->next;
2922         }
2923
2924         return NULL;
2925 }
2926
2927
2928 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2929 {
2930         struct wpa_global *global = wpa_s->global;
2931
2932         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2933                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2934                 if (global->drv_priv[i] == NULL) {
2935                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2936                                    "'%s'", wpa_drivers[i]->name);
2937                         return -1;
2938                 }
2939         }
2940
2941         wpa_s->driver = wpa_drivers[i];
2942         wpa_s->global_drv_priv = global->drv_priv[i];
2943
2944         return 0;
2945 }
2946
2947
2948 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2949                                      const char *name)
2950 {
2951         int i;
2952         size_t len;
2953         const char *pos, *driver = name;
2954
2955         if (wpa_s == NULL)
2956                 return -1;
2957
2958         if (wpa_drivers[0] == NULL) {
2959                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2960                         "wpa_supplicant");
2961                 return -1;
2962         }
2963
2964         if (name == NULL) {
2965                 /* default to first driver in the list */
2966                 return select_driver(wpa_s, 0);
2967         }
2968
2969         do {
2970                 pos = os_strchr(driver, ',');
2971                 if (pos)
2972                         len = pos - driver;
2973                 else
2974                         len = os_strlen(driver);
2975
2976                 for (i = 0; wpa_drivers[i]; i++) {
2977                         if (os_strlen(wpa_drivers[i]->name) == len &&
2978                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
2979                             0) {
2980                                 /* First driver that succeeds wins */
2981                                 if (select_driver(wpa_s, i) == 0)
2982                                         return 0;
2983                         }
2984                 }
2985
2986                 driver = pos + 1;
2987         } while (pos);
2988
2989         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2990         return -1;
2991 }
2992
2993
2994 /**
2995  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2996  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2997  *      with struct wpa_driver_ops::init()
2998  * @src_addr: Source address of the EAPOL frame
2999  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3000  * @len: Length of the EAPOL data
3001  *
3002  * This function is called for each received EAPOL frame. Most driver
3003  * interfaces rely on more generic OS mechanism for receiving frames through
3004  * l2_packet, but if such a mechanism is not available, the driver wrapper may
3005  * take care of received EAPOL frames and deliver them to the core supplicant
3006  * code by calling this function.
3007  */
3008 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
3009                              const u8 *buf, size_t len)
3010 {
3011         struct wpa_supplicant *wpa_s = ctx;
3012
3013         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3014         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
3015
3016 #ifdef CONFIG_PEERKEY
3017         if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
3018             wpa_s->current_ssid->peerkey &&
3019             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
3020             wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
3021                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
3022                 return;
3023         }
3024 #endif /* CONFIG_PEERKEY */
3025
3026         if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3027             (wpa_s->last_eapol_matches_bssid &&
3028 #ifdef CONFIG_AP
3029              !wpa_s->ap_iface &&
3030 #endif /* CONFIG_AP */
3031              os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3032                 /*
3033                  * There is possible race condition between receiving the
3034                  * association event and the EAPOL frame since they are coming
3035                  * through different paths from the driver. In order to avoid
3036                  * issues in trying to process the EAPOL frame before receiving
3037                  * association information, lets queue it for processing until
3038                  * the association event is received. This may also be needed in
3039                  * driver-based roaming case, so also use src_addr != BSSID as a
3040                  * trigger if we have previously confirmed that the
3041                  * Authenticator uses BSSID as the src_addr (which is not the
3042                  * case with wired IEEE 802.1X).
3043                  */
3044                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3045                         "of received EAPOL frame (state=%s bssid=" MACSTR ")",
3046                         wpa_supplicant_state_txt(wpa_s->wpa_state),
3047                         MAC2STR(wpa_s->bssid));
3048                 wpabuf_free(wpa_s->pending_eapol_rx);
3049                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3050                 if (wpa_s->pending_eapol_rx) {
3051                         os_get_reltime(&wpa_s->pending_eapol_rx_time);
3052                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3053                                   ETH_ALEN);
3054                 }
3055                 return;
3056         }
3057
3058         wpa_s->last_eapol_matches_bssid =
3059                 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3060
3061 #ifdef CONFIG_AP
3062         if (wpa_s->ap_iface) {
3063                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3064                 return;
3065         }
3066 #endif /* CONFIG_AP */
3067
3068         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3069                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3070                         "no key management is configured");
3071                 return;
3072         }
3073
3074         if (wpa_s->eapol_received == 0 &&
3075             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3076              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3077              wpa_s->wpa_state != WPA_COMPLETED) &&
3078             (wpa_s->current_ssid == NULL ||
3079              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3080                 /* Timeout for completing IEEE 802.1X and WPA authentication */
3081                 int timeout = 10;
3082
3083                 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3084                     wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3085                     wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3086                         /* Use longer timeout for IEEE 802.1X/EAP */
3087                         timeout = 70;
3088                 }
3089
3090 #ifdef CONFIG_WPS
3091                 if (wpa_s->current_ssid && wpa_s->current_bss &&
3092                     (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3093                     eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3094                         /*
3095                          * Use shorter timeout if going through WPS AP iteration
3096                          * for PIN config method with an AP that does not
3097                          * advertise Selected Registrar.
3098                          */
3099                         struct wpabuf *wps_ie;
3100
3101                         wps_ie = wpa_bss_get_vendor_ie_multi(
3102                                 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3103                         if (wps_ie &&
3104                             !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3105                                 timeout = 10;
3106                         wpabuf_free(wps_ie);
3107                 }
3108 #endif /* CONFIG_WPS */
3109
3110                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3111         }
3112         wpa_s->eapol_received++;
3113
3114         if (wpa_s->countermeasures) {
3115                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3116                         "EAPOL packet");
3117                 return;
3118         }
3119
3120 #ifdef CONFIG_IBSS_RSN
3121         if (wpa_s->current_ssid &&
3122             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3123                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3124                 return;
3125         }
3126 #endif /* CONFIG_IBSS_RSN */
3127
3128         /* Source address of the incoming EAPOL frame could be compared to the
3129          * current BSSID. However, it is possible that a centralized
3130          * Authenticator could be using another MAC address than the BSSID of
3131          * an AP, so just allow any address to be used for now. The replies are
3132          * still sent to the current BSSID (if available), though. */
3133
3134         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3135         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3136             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3137                 return;
3138         wpa_drv_poll(wpa_s);
3139         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3140                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3141         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3142                 /*
3143                  * Set portValid = TRUE here since we are going to skip 4-way
3144                  * handshake processing which would normally set portValid. We
3145                  * need this to allow the EAPOL state machines to be completed
3146                  * without going through EAPOL-Key handshake.
3147                  */
3148                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3149         }
3150 }
3151
3152
3153 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3154 {
3155         if ((!wpa_s->p2p_mgmt ||
3156              !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3157             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3158                 l2_packet_deinit(wpa_s->l2);
3159                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3160                                            wpa_drv_get_mac_addr(wpa_s),
3161                                            ETH_P_EAPOL,
3162                                            wpa_supplicant_rx_eapol, wpa_s, 0);
3163                 if (wpa_s->l2 == NULL)
3164                         return -1;
3165         } else {
3166                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3167                 if (addr)
3168                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3169         }
3170
3171         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3172                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3173                 return -1;
3174         }
3175
3176         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3177
3178         return 0;
3179 }
3180
3181
3182 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
3183                                            const u8 *buf, size_t len)
3184 {
3185         struct wpa_supplicant *wpa_s = ctx;
3186         const struct l2_ethhdr *eth;
3187
3188         if (len < sizeof(*eth))
3189                 return;
3190         eth = (const struct l2_ethhdr *) buf;
3191
3192         if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3193             !(eth->h_dest[0] & 0x01)) {
3194                 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3195                         " (bridge - not for this interface - ignore)",
3196                         MAC2STR(src_addr), MAC2STR(eth->h_dest));
3197                 return;
3198         }
3199
3200         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3201                 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
3202         wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
3203                                 len - sizeof(*eth));
3204 }
3205
3206
3207 /**
3208  * wpa_supplicant_driver_init - Initialize driver interface parameters
3209  * @wpa_s: Pointer to wpa_supplicant data
3210  * Returns: 0 on success, -1 on failure
3211  *
3212  * This function is called to initialize driver interface parameters.
3213  * wpa_drv_init() must have been called before this function to initialize the
3214  * driver interface.
3215  */
3216 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
3217 {
3218         static int interface_count = 0;
3219
3220         if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
3221                 return -1;
3222
3223         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
3224                 MAC2STR(wpa_s->own_addr));
3225         os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
3226         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3227
3228         if (wpa_s->bridge_ifname[0]) {
3229                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
3230                         "interface '%s'", wpa_s->bridge_ifname);
3231                 wpa_s->l2_br = l2_packet_init_bridge(
3232                         wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
3233                         ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
3234                 if (wpa_s->l2_br == NULL) {
3235                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
3236                                 "connection for the bridge interface '%s'",
3237                                 wpa_s->bridge_ifname);
3238                         return -1;
3239                 }
3240         }
3241
3242         wpa_clear_keys(wpa_s, NULL);
3243
3244         /* Make sure that TKIP countermeasures are not left enabled (could
3245          * happen if wpa_supplicant is killed during countermeasures. */
3246         wpa_drv_set_countermeasures(wpa_s, 0);
3247
3248         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
3249         wpa_drv_flush_pmkid(wpa_s);
3250
3251         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
3252         wpa_s->prev_scan_wildcard = 0;
3253
3254         if (wpa_supplicant_enabled_networks(wpa_s)) {
3255                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
3256                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3257                         interface_count = 0;
3258                 }
3259 #ifndef ANDROID
3260                 if (!wpa_s->p2p_mgmt &&
3261                     wpa_supplicant_delayed_sched_scan(wpa_s,
3262                                                       interface_count % 3,
3263                                                       100000))
3264                         wpa_supplicant_req_scan(wpa_s, interface_count % 3,
3265                                                 100000);
3266 #endif /* ANDROID */
3267                 interface_count++;
3268         } else
3269                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
3270
3271         return 0;
3272 }
3273
3274
3275 static int wpa_supplicant_daemon(const char *pid_file)
3276 {
3277         wpa_printf(MSG_DEBUG, "Daemonize..");
3278         return os_daemonize(pid_file);
3279 }
3280
3281
3282 static struct wpa_supplicant *
3283 wpa_supplicant_alloc(struct wpa_supplicant *parent)
3284 {
3285         struct wpa_supplicant *wpa_s;
3286
3287         wpa_s = os_zalloc(sizeof(*wpa_s));
3288         if (wpa_s == NULL)
3289                 return NULL;
3290         wpa_s->scan_req = INITIAL_SCAN_REQ;
3291         wpa_s->scan_interval = 5;
3292         wpa_s->new_connection = 1;
3293         wpa_s->parent = parent ? parent : wpa_s;
3294         wpa_s->sched_scanning = 0;
3295
3296         return wpa_s;
3297 }
3298
3299
3300 #ifdef CONFIG_HT_OVERRIDES
3301
3302 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
3303                              struct ieee80211_ht_capabilities *htcaps,
3304                              struct ieee80211_ht_capabilities *htcaps_mask,
3305                              const char *ht_mcs)
3306 {
3307         /* parse ht_mcs into hex array */
3308         int i;
3309         const char *tmp = ht_mcs;
3310         char *end = NULL;
3311
3312         /* If ht_mcs is null, do not set anything */
3313         if (!ht_mcs)
3314                 return 0;
3315
3316         /* This is what we are setting in the kernel */
3317         os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
3318
3319         wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
3320
3321         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3322                 errno = 0;
3323                 long v = strtol(tmp, &end, 16);
3324                 if (errno == 0) {
3325                         wpa_msg(wpa_s, MSG_DEBUG,
3326                                 "htcap value[%i]: %ld end: %p  tmp: %p",
3327                                 i, v, end, tmp);
3328                         if (end == tmp)
3329                                 break;
3330
3331                         htcaps->supported_mcs_set[i] = v;
3332                         tmp = end;
3333                 } else {
3334                         wpa_msg(wpa_s, MSG_ERROR,
3335                                 "Failed to parse ht-mcs: %s, error: %s\n",
3336                                 ht_mcs, strerror(errno));
3337                         return -1;
3338                 }
3339         }
3340
3341         /*
3342          * If we were able to parse any values, then set mask for the MCS set.
3343          */
3344         if (i) {
3345                 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
3346                           IEEE80211_HT_MCS_MASK_LEN - 1);
3347                 /* skip the 3 reserved bits */
3348                 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
3349                         0x1f;
3350         }
3351
3352         return 0;
3353 }
3354
3355
3356 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
3357                                  struct ieee80211_ht_capabilities *htcaps,
3358                                  struct ieee80211_ht_capabilities *htcaps_mask,
3359                                  int disabled)
3360 {
3361         le16 msk;
3362
3363         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3364
3365         if (disabled == -1)
3366                 return 0;
3367
3368         msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3369         htcaps_mask->ht_capabilities_info |= msk;
3370         if (disabled)
3371                 htcaps->ht_capabilities_info &= msk;
3372         else
3373                 htcaps->ht_capabilities_info |= msk;
3374
3375         return 0;
3376 }
3377
3378
3379 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3380                                 struct ieee80211_ht_capabilities *htcaps,
3381                                 struct ieee80211_ht_capabilities *htcaps_mask,
3382                                 int factor)
3383 {
3384         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3385
3386         if (factor == -1)
3387                 return 0;
3388
3389         if (factor < 0 || factor > 3) {
3390                 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3391                         "Must be 0-3 or -1", factor);
3392                 return -EINVAL;
3393         }
3394
3395         htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3396         htcaps->a_mpdu_params &= ~0x3;
3397         htcaps->a_mpdu_params |= factor & 0x3;
3398
3399         return 0;
3400 }
3401
3402
3403 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3404                                  struct ieee80211_ht_capabilities *htcaps,
3405                                  struct ieee80211_ht_capabilities *htcaps_mask,
3406                                  int density)
3407 {
3408         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3409
3410         if (density == -1)
3411                 return 0;
3412
3413         if (density < 0 || density > 7) {
3414                 wpa_msg(wpa_s, MSG_ERROR,
3415                         "ampdu_density: %d out of range. Must be 0-7 or -1.",
3416                         density);
3417                 return -EINVAL;
3418         }
3419
3420         htcaps_mask->a_mpdu_params |= 0x1C;
3421         htcaps->a_mpdu_params &= ~(0x1C);
3422         htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3423
3424         return 0;
3425 }
3426
3427
3428 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3429                                 struct ieee80211_ht_capabilities *htcaps,
3430                                 struct ieee80211_ht_capabilities *htcaps_mask,
3431                                 int disabled)
3432 {
3433         /* Masking these out disables HT40 */
3434         le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3435                                 HT_CAP_INFO_SHORT_GI40MHZ);
3436
3437         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3438
3439         if (disabled)
3440                 htcaps->ht_capabilities_info &= ~msk;
3441         else
3442                 htcaps->ht_capabilities_info |= msk;
3443
3444         htcaps_mask->ht_capabilities_info |= msk;
3445
3446         return 0;
3447 }
3448
3449
3450 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3451                                struct ieee80211_ht_capabilities *htcaps,
3452                                struct ieee80211_ht_capabilities *htcaps_mask,
3453                                int disabled)
3454 {
3455         /* Masking these out disables SGI */
3456         le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3457                                 HT_CAP_INFO_SHORT_GI40MHZ);
3458
3459         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3460
3461         if (disabled)
3462                 htcaps->ht_capabilities_info &= ~msk;
3463         else
3464                 htcaps->ht_capabilities_info |= msk;
3465
3466         htcaps_mask->ht_capabilities_info |= msk;
3467
3468         return 0;
3469 }
3470
3471
3472 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3473                                struct ieee80211_ht_capabilities *htcaps,
3474                                struct ieee80211_ht_capabilities *htcaps_mask,
3475                                int disabled)
3476 {
3477         /* Masking these out disables LDPC */
3478         le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
3479
3480         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3481
3482         if (disabled)
3483                 htcaps->ht_capabilities_info &= ~msk;
3484         else
3485                 htcaps->ht_capabilities_info |= msk;
3486
3487         htcaps_mask->ht_capabilities_info |= msk;
3488
3489         return 0;
3490 }
3491
3492
3493 void wpa_supplicant_apply_ht_overrides(
3494         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3495         struct wpa_driver_associate_params *params)
3496 {
3497         struct ieee80211_ht_capabilities *htcaps;
3498         struct ieee80211_ht_capabilities *htcaps_mask;
3499
3500         if (!ssid)
3501                 return;
3502
3503         params->disable_ht = ssid->disable_ht;
3504         if (!params->htcaps || !params->htcaps_mask)
3505                 return;
3506
3507         htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3508         htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3509         wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3510         wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3511                               ssid->disable_max_amsdu);
3512         wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3513         wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3514         wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3515         wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3516         wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3517
3518         if (ssid->ht40_intolerant) {
3519                 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
3520                 htcaps->ht_capabilities_info |= bit;
3521                 htcaps_mask->ht_capabilities_info |= bit;
3522         }
3523 }
3524
3525 #endif /* CONFIG_HT_OVERRIDES */
3526
3527
3528 #ifdef CONFIG_VHT_OVERRIDES
3529 void wpa_supplicant_apply_vht_overrides(
3530         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3531         struct wpa_driver_associate_params *params)
3532 {
3533         struct ieee80211_vht_capabilities *vhtcaps;
3534         struct ieee80211_vht_capabilities *vhtcaps_mask;
3535
3536         if (!ssid)
3537                 return;
3538
3539         params->disable_vht = ssid->disable_vht;
3540
3541         vhtcaps = (void *) params->vhtcaps;
3542         vhtcaps_mask = (void *) params->vhtcaps_mask;
3543
3544         if (!vhtcaps || !vhtcaps_mask)
3545                 return;
3546
3547         vhtcaps->vht_capabilities_info = ssid->vht_capa;
3548         vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
3549
3550 #ifdef CONFIG_HT_OVERRIDES
3551         /* if max ampdu is <= 3, we have to make the HT cap the same */
3552         if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) {
3553                 int max_ampdu;
3554
3555                 max_ampdu = (ssid->vht_capa &
3556                              VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >>
3557                         VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT;
3558
3559                 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3560                 wpa_set_ampdu_factor(wpa_s,
3561                                      (void *) params->htcaps,
3562                                      (void *) params->htcaps_mask,
3563                                      max_ampdu);
3564         }
3565 #endif /* CONFIG_HT_OVERRIDES */
3566
3567 #define OVERRIDE_MCS(i)                                                 \
3568         if (ssid->vht_tx_mcs_nss_ ##i >= 0) {                           \
3569                 vhtcaps_mask->vht_supported_mcs_set.tx_map |=           \
3570                         3 << 2 * (i - 1);                               \
3571                 vhtcaps->vht_supported_mcs_set.tx_map |=                \
3572                         ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1);       \
3573         }                                                               \
3574         if (ssid->vht_rx_mcs_nss_ ##i >= 0) {                           \
3575                 vhtcaps_mask->vht_supported_mcs_set.rx_map |=           \
3576                         3 << 2 * (i - 1);                               \
3577                 vhtcaps->vht_supported_mcs_set.rx_map |=                \
3578                         ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1);       \
3579         }
3580
3581         OVERRIDE_MCS(1);
3582         OVERRIDE_MCS(2);
3583         OVERRIDE_MCS(3);
3584         OVERRIDE_MCS(4);
3585         OVERRIDE_MCS(5);
3586         OVERRIDE_MCS(6);
3587         OVERRIDE_MCS(7);
3588         OVERRIDE_MCS(8);
3589 }
3590 #endif /* CONFIG_VHT_OVERRIDES */
3591
3592
3593 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3594 {
3595 #ifdef PCSC_FUNCS
3596         size_t len;
3597
3598         if (!wpa_s->conf->pcsc_reader)
3599                 return 0;
3600
3601         wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3602         if (!wpa_s->scard)
3603                 return 1;
3604
3605         if (wpa_s->conf->pcsc_pin &&
3606             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3607                 scard_deinit(wpa_s->scard);
3608                 wpa_s->scard = NULL;
3609                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3610                 return -1;
3611         }
3612
3613         len = sizeof(wpa_s->imsi) - 1;
3614         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3615                 scard_deinit(wpa_s->scard);
3616                 wpa_s->scard = NULL;
3617                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3618                 return -1;
3619         }
3620         wpa_s->imsi[len] = '\0';
3621
3622         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3623
3624         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3625                    wpa_s->imsi, wpa_s->mnc_len);
3626
3627         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3628         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3629 #endif /* PCSC_FUNCS */
3630
3631         return 0;
3632 }
3633
3634
3635 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3636 {
3637         char *val, *pos;
3638
3639         ext_password_deinit(wpa_s->ext_pw);
3640         wpa_s->ext_pw = NULL;
3641         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3642
3643         if (!wpa_s->conf->ext_password_backend)
3644                 return 0;
3645
3646         val = os_strdup(wpa_s->conf->ext_password_backend);
3647         if (val == NULL)
3648                 return -1;
3649         pos = os_strchr(val, ':');
3650         if (pos)
3651                 *pos++ = '\0';
3652
3653         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
3654
3655         wpa_s->ext_pw = ext_password_init(val, pos);
3656         os_free(val);
3657         if (wpa_s->ext_pw == NULL) {
3658                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
3659                 return -1;
3660         }
3661         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3662
3663         return 0;
3664 }
3665
3666
3667 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
3668                                     const struct wpa_driver_capa *capa)
3669 {
3670         struct wowlan_triggers *triggers;
3671         int ret = 0;
3672
3673         if (!wpa_s->conf->wowlan_triggers)
3674                 return 0;
3675
3676         triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
3677         if (triggers) {
3678                 ret = wpa_drv_wowlan(wpa_s, triggers);
3679                 os_free(triggers);
3680         }
3681         return ret;
3682 }
3683
3684
3685 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
3686                                               const char *rn)
3687 {
3688         struct wpa_supplicant *iface = wpa_s->global->ifaces;
3689         struct wpa_radio *radio;
3690
3691         while (rn && iface) {
3692                 radio = iface->radio;
3693                 if (radio && os_strcmp(rn, radio->name) == 0) {
3694                         wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
3695                                    wpa_s->ifname, rn);
3696                         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3697                         return radio;
3698                 }
3699
3700                 iface = iface->next;
3701         }
3702
3703         wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
3704                    wpa_s->ifname, rn ? rn : "N/A");
3705         radio = os_zalloc(sizeof(*radio));
3706         if (radio == NULL)
3707                 return NULL;
3708
3709         if (rn)
3710                 os_strlcpy(radio->name, rn, sizeof(radio->name));
3711         dl_list_init(&radio->ifaces);
3712         dl_list_init(&radio->work);
3713         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3714
3715         return radio;
3716 }
3717
3718
3719 static void radio_work_free(struct wpa_radio_work *work)
3720 {
3721         if (work->wpa_s->scan_work == work) {
3722                 /* This should not really happen. */
3723                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3724                         work->type, work, work->started);
3725                 work->wpa_s->scan_work = NULL;
3726         }
3727
3728 #ifdef CONFIG_P2P
3729         if (work->wpa_s->p2p_scan_work == work) {
3730                 /* This should not really happen. */
3731                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3732                         work->type, work, work->started);
3733                 work->wpa_s->p2p_scan_work = NULL;
3734         }
3735 #endif /* CONFIG_P2P */
3736
3737         dl_list_del(&work->list);
3738         os_free(work);
3739 }
3740
3741
3742 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
3743 {
3744         struct wpa_radio *radio = eloop_ctx;
3745         struct wpa_radio_work *work;
3746         struct os_reltime now, diff;
3747         struct wpa_supplicant *wpa_s;
3748
3749         work = dl_list_first(&radio->work, struct wpa_radio_work, list);
3750         if (work == NULL)
3751                 return;
3752
3753         if (work->started)
3754                 return; /* already started and still in progress */
3755
3756         wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
3757                               radio_list);
3758         if (wpa_s && wpa_s->radio->external_scan_running) {
3759                 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
3760                 return;
3761         }
3762
3763         os_get_reltime(&now);
3764         os_reltime_sub(&now, &work->time, &diff);
3765         wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3766                 work->type, work, diff.sec, diff.usec);
3767         work->started = 1;
3768         work->time = now;
3769         work->cb(work, 0);
3770 }
3771
3772
3773 /*
3774  * This function removes both started and pending radio works running on
3775  * the provided interface's radio.
3776  * Prior to the removal of the radio work, its callback (cb) is called with
3777  * deinit set to be 1. Each work's callback is responsible for clearing its
3778  * internal data and restoring to a correct state.
3779  * @wpa_s: wpa_supplicant data
3780  * @type: type of works to be removed
3781  * @remove_all: 1 to remove all the works on this radio, 0 to remove only
3782  * this interface's works.
3783  */
3784 void radio_remove_works(struct wpa_supplicant *wpa_s,
3785                         const char *type, int remove_all)
3786 {
3787         struct wpa_radio_work *work, *tmp;
3788         struct wpa_radio *radio = wpa_s->radio;
3789
3790         dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
3791                               list) {
3792                 if (type && os_strcmp(type, work->type) != 0)
3793                         continue;
3794
3795                 /* skip other ifaces' works */
3796                 if (!remove_all && work->wpa_s != wpa_s)
3797                         continue;
3798
3799                 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
3800                         work->type, work, work->started ? " (started)" : "");
3801                 work->cb(work, 1);
3802                 radio_work_free(work);
3803         }
3804
3805         /* in case we removed the started work */
3806         radio_work_check_next(wpa_s);
3807 }
3808
3809
3810 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
3811 {
3812         struct wpa_radio *radio = wpa_s->radio;
3813
3814         if (!radio)
3815                 return;
3816
3817         wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
3818                    wpa_s->ifname, radio->name);
3819         dl_list_del(&wpa_s->radio_list);
3820         radio_remove_works(wpa_s, NULL, 0);
3821         wpa_s->radio = NULL;
3822         if (!dl_list_empty(&radio->ifaces))
3823                 return; /* Interfaces remain for this radio */
3824
3825         wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
3826         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3827         os_free(radio);
3828 }
3829
3830
3831 void radio_work_check_next(struct wpa_supplicant *wpa_s)
3832 {
3833         struct wpa_radio *radio = wpa_s->radio;
3834
3835         if (dl_list_empty(&radio->work))
3836                 return;
3837         if (wpa_s->ext_work_in_progress) {
3838                 wpa_printf(MSG_DEBUG,
3839                            "External radio work in progress - delay start of pending item");
3840                 return;
3841         }
3842         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3843         eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
3844 }
3845
3846
3847 /**
3848  * radio_add_work - Add a radio work item
3849  * @wpa_s: Pointer to wpa_supplicant data
3850  * @freq: Frequency of the offchannel operation in MHz or 0
3851  * @type: Unique identifier for each type of work
3852  * @next: Force as the next work to be executed
3853  * @cb: Callback function for indicating when radio is available
3854  * @ctx: Context pointer for the work (work->ctx in cb())
3855  * Returns: 0 on success, -1 on failure
3856  *
3857  * This function is used to request time for an operation that requires
3858  * exclusive radio control. Once the radio is available, the registered callback
3859  * function will be called. radio_work_done() must be called once the exclusive
3860  * radio operation has been completed, so that the radio is freed for other
3861  * operations. The special case of deinit=1 is used to free the context data
3862  * during interface removal. That does not allow the callback function to start
3863  * the radio operation, i.e., it must free any resources allocated for the radio
3864  * work and return.
3865  *
3866  * The @freq parameter can be used to indicate a single channel on which the
3867  * offchannel operation will occur. This may allow multiple radio work
3868  * operations to be performed in parallel if they apply for the same channel.
3869  * Setting this to 0 indicates that the work item may use multiple channels or
3870  * requires exclusive control of the radio.
3871  */
3872 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
3873                    const char *type, int next,
3874                    void (*cb)(struct wpa_radio_work *work, int deinit),
3875                    void *ctx)
3876 {
3877         struct wpa_radio_work *work;
3878         int was_empty;
3879
3880         work = os_zalloc(sizeof(*work));
3881         if (work == NULL)
3882                 return -1;
3883         wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
3884         os_get_reltime(&work->time);
3885         work->freq = freq;
3886         work->type = type;
3887         work->wpa_s = wpa_s;
3888         work->cb = cb;
3889         work->ctx = ctx;
3890
3891         was_empty = dl_list_empty(&wpa_s->radio->work);
3892         if (next)
3893                 dl_list_add(&wpa_s->radio->work, &work->list);
3894         else
3895                 dl_list_add_tail(&wpa_s->radio->work, &work->list);
3896         if (was_empty) {
3897                 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
3898                 radio_work_check_next(wpa_s);
3899         }
3900
3901         return 0;
3902 }
3903
3904
3905 /**
3906  * radio_work_done - Indicate that a radio work item has been completed
3907  * @work: Completed work
3908  *
3909  * This function is called once the callback function registered with
3910  * radio_add_work() has completed its work.
3911  */
3912 void radio_work_done(struct wpa_radio_work *work)
3913 {
3914         struct wpa_supplicant *wpa_s = work->wpa_s;
3915         struct os_reltime now, diff;
3916         unsigned int started = work->started;
3917
3918         os_get_reltime(&now);
3919         os_reltime_sub(&now, &work->time, &diff);
3920         wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3921                 work->type, work, started ? "done" : "canceled",
3922                 diff.sec, diff.usec);
3923         radio_work_free(work);
3924         if (started)
3925                 radio_work_check_next(wpa_s);
3926 }
3927
3928
3929 struct wpa_radio_work *
3930 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
3931 {
3932         struct wpa_radio_work *work;
3933         struct wpa_radio *radio = wpa_s->radio;
3934
3935         dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
3936                 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
3937                         return work;
3938         }
3939
3940         return NULL;
3941 }
3942
3943
3944 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
3945                             struct wpa_interface *iface)
3946 {
3947         const char *ifname, *driver, *rn;
3948
3949         driver = iface->driver;
3950 next_driver:
3951         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
3952                 return -1;
3953
3954         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
3955         if (wpa_s->drv_priv == NULL) {
3956                 const char *pos;
3957                 pos = driver ? os_strchr(driver, ',') : NULL;
3958                 if (pos) {
3959                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
3960                                 "driver interface - try next driver wrapper");
3961                         driver = pos + 1;
3962                         goto next_driver;
3963                 }
3964                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
3965                         "interface");
3966                 return -1;
3967         }
3968         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
3969                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
3970                         "driver_param '%s'", wpa_s->conf->driver_param);
3971                 return -1;
3972         }
3973
3974         ifname = wpa_drv_get_ifname(wpa_s);
3975         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
3976                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
3977                         "interface name with '%s'", ifname);
3978                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
3979         }
3980
3981         rn = wpa_driver_get_radio_name(wpa_s);
3982         if (rn && rn[0] == '\0')
3983                 rn = NULL;
3984
3985         wpa_s->radio = radio_add_interface(wpa_s, rn);
3986         if (wpa_s->radio == NULL)
3987                 return -1;
3988
3989         return 0;
3990 }
3991
3992
3993 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
3994                                      struct wpa_interface *iface)
3995 {
3996         struct wpa_driver_capa capa;
3997         int capa_res;
3998
3999         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
4000                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
4001                    iface->confname ? iface->confname : "N/A",
4002                    iface->driver ? iface->driver : "default",
4003                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
4004                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
4005
4006         if (iface->confname) {
4007 #ifdef CONFIG_BACKEND_FILE
4008                 wpa_s->confname = os_rel2abs_path(iface->confname);
4009                 if (wpa_s->confname == NULL) {
4010                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
4011                                    "for configuration file '%s'.",
4012                                    iface->confname);
4013                         return -1;
4014                 }
4015                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
4016                            iface->confname, wpa_s->confname);
4017 #else /* CONFIG_BACKEND_FILE */
4018                 wpa_s->confname = os_strdup(iface->confname);
4019 #endif /* CONFIG_BACKEND_FILE */
4020                 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
4021                 if (wpa_s->conf == NULL) {
4022                         wpa_printf(MSG_ERROR, "Failed to read or parse "
4023                                    "configuration '%s'.", wpa_s->confname);
4024                         return -1;
4025                 }
4026                 wpa_s->confanother = os_rel2abs_path(iface->confanother);
4027                 wpa_config_read(wpa_s->confanother, wpa_s->conf);
4028
4029                 /*
4030                  * Override ctrl_interface and driver_param if set on command
4031                  * line.
4032                  */
4033                 if (iface->ctrl_interface) {
4034                         os_free(wpa_s->conf->ctrl_interface);
4035                         wpa_s->conf->ctrl_interface =
4036                                 os_strdup(iface->ctrl_interface);
4037                 }
4038
4039                 if (iface->driver_param) {
4040                         os_free(wpa_s->conf->driver_param);
4041                         wpa_s->conf->driver_param =
4042                                 os_strdup(iface->driver_param);
4043                 }
4044
4045                 if (iface->p2p_mgmt && !iface->ctrl_interface) {
4046                         os_free(wpa_s->conf->ctrl_interface);
4047                         wpa_s->conf->ctrl_interface = NULL;
4048                 }
4049         } else
4050                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
4051                                                      iface->driver_param);
4052
4053         if (wpa_s->conf == NULL) {
4054                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
4055                 return -1;
4056         }
4057
4058         if (iface->ifname == NULL) {
4059                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
4060                 return -1;
4061         }
4062         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
4063                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
4064                            iface->ifname);
4065                 return -1;
4066         }
4067         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
4068
4069         if (iface->bridge_ifname) {
4070                 if (os_strlen(iface->bridge_ifname) >=
4071                     sizeof(wpa_s->bridge_ifname)) {
4072                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
4073                                    "name '%s'.", iface->bridge_ifname);
4074                         return -1;
4075                 }
4076                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
4077                            sizeof(wpa_s->bridge_ifname));
4078         }
4079
4080         /* RSNA Supplicant Key Management - INITIALIZE */
4081         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
4082         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
4083
4084         /* Initialize driver interface and register driver event handler before
4085          * L2 receive handler so that association events are processed before
4086          * EAPOL-Key packets if both become available for the same select()
4087          * call. */
4088         if (wpas_init_driver(wpa_s, iface) < 0)
4089                 return -1;
4090
4091         if (wpa_supplicant_init_wpa(wpa_s) < 0)
4092                 return -1;
4093
4094         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
4095                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
4096                           NULL);
4097         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
4098
4099         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
4100             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
4101                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
4102                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4103                         "dot11RSNAConfigPMKLifetime");
4104                 return -1;
4105         }
4106
4107         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
4108             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
4109                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
4110                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4111                         "dot11RSNAConfigPMKReauthThreshold");
4112                 return -1;
4113         }
4114
4115         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
4116             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
4117                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
4118                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4119                         "dot11RSNAConfigSATimeout");
4120                 return -1;
4121         }
4122
4123         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
4124                                                       &wpa_s->hw.num_modes,
4125                                                       &wpa_s->hw.flags);
4126         if (wpa_s->hw.modes) {
4127                 u16 i;
4128
4129                 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4130                         if (wpa_s->hw.modes[i].vht_capab) {
4131                                 wpa_s->hw_capab = CAPAB_VHT;
4132                                 break;
4133                         }
4134
4135                         if (wpa_s->hw.modes[i].ht_capab &
4136                             HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)
4137                                 wpa_s->hw_capab = CAPAB_HT40;
4138                         else if (wpa_s->hw.modes[i].ht_capab &&
4139                                  wpa_s->hw_capab == CAPAB_NO_HT_VHT)
4140                                 wpa_s->hw_capab = CAPAB_HT;
4141                 }
4142         }
4143
4144         capa_res = wpa_drv_get_capa(wpa_s, &capa);
4145         if (capa_res == 0) {
4146                 wpa_s->drv_capa_known = 1;
4147                 wpa_s->drv_flags = capa.flags;
4148                 wpa_s->drv_enc = capa.enc;
4149                 wpa_s->drv_smps_modes = capa.smps_modes;
4150                 wpa_s->drv_rrm_flags = capa.rrm_flags;
4151                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
4152                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
4153                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
4154                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
4155                 wpa_s->max_match_sets = capa.max_match_sets;
4156                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
4157                 wpa_s->max_stations = capa.max_stations;
4158                 wpa_s->extended_capa = capa.extended_capa;
4159                 wpa_s->extended_capa_mask = capa.extended_capa_mask;
4160                 wpa_s->extended_capa_len = capa.extended_capa_len;
4161                 wpa_s->num_multichan_concurrent =
4162                         capa.num_multichan_concurrent;
4163                 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
4164
4165                 if (capa.mac_addr_rand_scan_supported)
4166                         wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
4167                 if (wpa_s->sched_scan_supported &&
4168                     capa.mac_addr_rand_sched_scan_supported)
4169                         wpa_s->mac_addr_rand_supported |=
4170                                 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO);
4171         }
4172         if (wpa_s->max_remain_on_chan == 0)
4173                 wpa_s->max_remain_on_chan = 1000;
4174
4175         /*
4176          * Only take p2p_mgmt parameters when P2P Device is supported.
4177          * Doing it here as it determines whether l2_packet_init() will be done
4178          * during wpa_supplicant_driver_init().
4179          */
4180         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
4181                 wpa_s->p2p_mgmt = iface->p2p_mgmt;
4182         else
4183                 iface->p2p_mgmt = 1;
4184
4185         if (wpa_s->num_multichan_concurrent == 0)
4186                 wpa_s->num_multichan_concurrent = 1;
4187
4188         if (wpa_supplicant_driver_init(wpa_s) < 0)
4189                 return -1;
4190
4191 #ifdef CONFIG_TDLS
4192         if ((!iface->p2p_mgmt ||
4193              !(wpa_s->drv_flags &
4194                WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
4195             wpa_tdls_init(wpa_s->wpa))
4196                 return -1;
4197 #endif /* CONFIG_TDLS */
4198
4199         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
4200             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
4201                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
4202                 return -1;
4203         }
4204
4205         if (wpas_wps_init(wpa_s))
4206                 return -1;
4207
4208         if (wpa_supplicant_init_eapol(wpa_s) < 0)
4209                 return -1;
4210         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
4211
4212         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
4213         if (wpa_s->ctrl_iface == NULL) {
4214                 wpa_printf(MSG_ERROR,
4215                            "Failed to initialize control interface '%s'.\n"
4216                            "You may have another wpa_supplicant process "
4217                            "already running or the file was\n"
4218                            "left by an unclean termination of wpa_supplicant "
4219                            "in which case you will need\n"
4220                            "to manually remove this file before starting "
4221                            "wpa_supplicant again.\n",
4222                            wpa_s->conf->ctrl_interface);
4223                 return -1;
4224         }
4225
4226         wpa_s->gas = gas_query_init(wpa_s);
4227         if (wpa_s->gas == NULL) {
4228                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
4229                 return -1;
4230         }
4231
4232         if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
4233                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
4234                 return -1;
4235         }
4236
4237         if (wpa_bss_init(wpa_s) < 0)
4238                 return -1;
4239
4240         /*
4241          * Set Wake-on-WLAN triggers, if configured.
4242          * Note: We don't restore/remove the triggers on shutdown (it doesn't
4243          * have effect anyway when the interface is down).
4244          */
4245         if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
4246                 return -1;
4247
4248 #ifdef CONFIG_EAP_PROXY
4249 {
4250         size_t len;
4251         wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
4252                                                      &len);
4253         if (wpa_s->mnc_len > 0) {
4254                 wpa_s->imsi[len] = '\0';
4255                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
4256                            wpa_s->imsi, wpa_s->mnc_len);
4257         } else {
4258                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
4259         }
4260 }
4261 #endif /* CONFIG_EAP_PROXY */
4262
4263         if (pcsc_reader_init(wpa_s) < 0)
4264                 return -1;
4265
4266         if (wpas_init_ext_pw(wpa_s) < 0)
4267                 return -1;
4268
4269         wpas_rrm_reset(wpa_s);
4270
4271         return 0;
4272 }
4273
4274
4275 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
4276                                         int notify, int terminate)
4277 {
4278         struct wpa_global *global = wpa_s->global;
4279         struct wpa_supplicant *iface, *prev;
4280
4281         if (wpa_s == wpa_s->parent)
4282                 wpas_p2p_group_remove(wpa_s, "*");
4283
4284         iface = global->ifaces;
4285         while (iface) {
4286                 if (iface == wpa_s || iface->parent != wpa_s) {
4287                         iface = iface->next;
4288                         continue;
4289                 }
4290                 wpa_printf(MSG_DEBUG,
4291                            "Remove remaining child interface %s from parent %s",
4292                            iface->ifname, wpa_s->ifname);
4293                 prev = iface;
4294                 iface = iface->next;
4295                 wpa_supplicant_remove_iface(global, prev, terminate);
4296         }
4297
4298         wpa_s->disconnected = 1;
4299         if (wpa_s->drv_priv) {
4300                 wpa_supplicant_deauthenticate(wpa_s,
4301                                               WLAN_REASON_DEAUTH_LEAVING);
4302
4303                 wpa_drv_set_countermeasures(wpa_s, 0);
4304                 wpa_clear_keys(wpa_s, NULL);
4305         }
4306
4307         wpa_supplicant_cleanup(wpa_s);
4308         wpas_p2p_deinit_iface(wpa_s);
4309
4310         wpas_ctrl_radio_work_flush(wpa_s);
4311         radio_remove_interface(wpa_s);
4312
4313         if (wpa_s->drv_priv)
4314                 wpa_drv_deinit(wpa_s);
4315
4316         if (notify)
4317                 wpas_notify_iface_removed(wpa_s);
4318
4319         if (terminate)
4320                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
4321
4322         if (wpa_s->ctrl_iface) {
4323                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
4324                 wpa_s->ctrl_iface = NULL;
4325         }
4326
4327 #ifdef CONFIG_MESH
4328         if (wpa_s->ifmsh) {
4329                 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
4330                 wpa_s->ifmsh = NULL;
4331         }
4332 #endif /* CONFIG_MESH */
4333
4334         if (wpa_s->conf != NULL) {
4335                 wpa_config_free(wpa_s->conf);
4336                 wpa_s->conf = NULL;
4337         }
4338
4339         os_free(wpa_s->ssids_from_scan_req);
4340
4341         os_free(wpa_s);
4342 }
4343
4344
4345 /**
4346  * wpa_supplicant_add_iface - Add a new network interface
4347  * @global: Pointer to global data from wpa_supplicant_init()
4348  * @iface: Interface configuration options
4349  * @parent: Parent interface or %NULL to assign new interface as parent
4350  * Returns: Pointer to the created interface or %NULL on failure
4351  *
4352  * This function is used to add new network interfaces for %wpa_supplicant.
4353  * This can be called before wpa_supplicant_run() to add interfaces before the
4354  * main event loop has been started. In addition, new interfaces can be added
4355  * dynamically while %wpa_supplicant is already running. This could happen,
4356  * e.g., when a hotplug network adapter is inserted.
4357  */
4358 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
4359                                                  struct wpa_interface *iface,
4360                                                  struct wpa_supplicant *parent)
4361 {
4362         struct wpa_supplicant *wpa_s;
4363         struct wpa_interface t_iface;
4364         struct wpa_ssid *ssid;
4365
4366         if (global == NULL || iface == NULL)
4367                 return NULL;
4368
4369         wpa_s = wpa_supplicant_alloc(parent);
4370         if (wpa_s == NULL)
4371                 return NULL;
4372
4373         wpa_s->global = global;
4374
4375         t_iface = *iface;
4376         if (global->params.override_driver) {
4377                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
4378                            "('%s' -> '%s')",
4379                            iface->driver, global->params.override_driver);
4380                 t_iface.driver = global->params.override_driver;
4381         }
4382         if (global->params.override_ctrl_interface) {
4383                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
4384                            "ctrl_interface ('%s' -> '%s')",
4385                            iface->ctrl_interface,
4386                            global->params.override_ctrl_interface);
4387                 t_iface.ctrl_interface =
4388                         global->params.override_ctrl_interface;
4389         }
4390         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
4391                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
4392                            iface->ifname);
4393                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
4394                 return NULL;
4395         }
4396
4397         if (iface->p2p_mgmt == 0) {
4398                 /* Notify the control interfaces about new iface */
4399                 if (wpas_notify_iface_added(wpa_s)) {
4400                         wpa_supplicant_deinit_iface(wpa_s, 1, 0);
4401                         return NULL;
4402                 }
4403
4404                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
4405                         wpas_notify_network_added(wpa_s, ssid);
4406         }
4407
4408         wpa_s->next = global->ifaces;
4409         global->ifaces = wpa_s;
4410
4411         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
4412         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
4413
4414 #ifdef CONFIG_P2P
4415         if (wpa_s->global->p2p == NULL &&
4416             !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
4417             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
4418             wpas_p2p_add_p2pdev_interface(wpa_s, iface->conf_p2p_dev) < 0) {
4419                 wpa_printf(MSG_INFO,
4420                            "P2P: Failed to enable P2P Device interface");
4421                 /* Try to continue without. P2P will be disabled. */
4422         }
4423 #endif /* CONFIG_P2P */
4424
4425         return wpa_s;
4426 }
4427
4428
4429 /**
4430  * wpa_supplicant_remove_iface - Remove a network interface
4431  * @global: Pointer to global data from wpa_supplicant_init()
4432  * @wpa_s: Pointer to the network interface to be removed
4433  * Returns: 0 if interface was removed, -1 if interface was not found
4434  *
4435  * This function can be used to dynamically remove network interfaces from
4436  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
4437  * addition, this function is used to remove all remaining interfaces when
4438  * %wpa_supplicant is terminated.
4439  */
4440 int wpa_supplicant_remove_iface(struct wpa_global *global,
4441                                 struct wpa_supplicant *wpa_s,
4442                                 int terminate)
4443 {
4444         struct wpa_supplicant *prev;
4445 #ifdef CONFIG_MESH
4446         unsigned int mesh_if_created = wpa_s->mesh_if_created;
4447         char *ifname = NULL;
4448 #endif /* CONFIG_MESH */
4449
4450         /* Remove interface from the global list of interfaces */
4451         prev = global->ifaces;
4452         if (prev == wpa_s) {
4453                 global->ifaces = wpa_s->next;
4454         } else {
4455                 while (prev && prev->next != wpa_s)
4456                         prev = prev->next;
4457                 if (prev == NULL)
4458                         return -1;
4459                 prev->next = wpa_s->next;
4460         }
4461
4462         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
4463
4464 #ifdef CONFIG_MESH
4465         if (mesh_if_created) {
4466                 ifname = os_strdup(wpa_s->ifname);
4467                 if (ifname == NULL) {
4468                         wpa_dbg(wpa_s, MSG_ERROR,
4469                                 "mesh: Failed to malloc ifname");
4470                         return -1;
4471                 }
4472         }
4473 #endif /* CONFIG_MESH */
4474
4475         if (global->p2p_group_formation == wpa_s)
4476                 global->p2p_group_formation = NULL;
4477         if (global->p2p_invite_group == wpa_s)
4478                 global->p2p_invite_group = NULL;
4479         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
4480
4481 #ifdef CONFIG_MESH
4482         if (mesh_if_created) {
4483                 wpa_drv_if_remove(global->ifaces, WPA_IF_MESH, ifname);
4484                 os_free(ifname);
4485         }
4486 #endif /* CONFIG_MESH */
4487
4488         return 0;
4489 }
4490
4491
4492 /**
4493  * wpa_supplicant_get_eap_mode - Get the current EAP mode
4494  * @wpa_s: Pointer to the network interface
4495  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
4496  */
4497 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
4498 {
4499         const char *eapol_method;
4500
4501         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
4502             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
4503                 return "NO-EAP";
4504         }
4505
4506         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
4507         if (eapol_method == NULL)
4508                 return "UNKNOWN-EAP";
4509
4510         return eapol_method;
4511 }
4512
4513
4514 /**
4515  * wpa_supplicant_get_iface - Get a new network interface
4516  * @global: Pointer to global data from wpa_supplicant_init()
4517  * @ifname: Interface name
4518  * Returns: Pointer to the interface or %NULL if not found
4519  */
4520 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
4521                                                  const char *ifname)
4522 {
4523         struct wpa_supplicant *wpa_s;
4524
4525         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4526                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
4527                         return wpa_s;
4528         }
4529         return NULL;
4530 }
4531
4532
4533 #ifndef CONFIG_NO_WPA_MSG
4534 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
4535 {
4536         struct wpa_supplicant *wpa_s = ctx;
4537         if (wpa_s == NULL)
4538                 return NULL;
4539         return wpa_s->ifname;
4540 }
4541 #endif /* CONFIG_NO_WPA_MSG */
4542
4543
4544 /**
4545  * wpa_supplicant_init - Initialize %wpa_supplicant
4546  * @params: Parameters for %wpa_supplicant
4547  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
4548  *
4549  * This function is used to initialize %wpa_supplicant. After successful
4550  * initialization, the returned data pointer can be used to add and remove
4551  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
4552  */
4553 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
4554 {
4555         struct wpa_global *global;
4556         int ret, i;
4557
4558         if (params == NULL)
4559                 return NULL;
4560
4561 #ifdef CONFIG_DRIVER_NDIS
4562         {
4563                 void driver_ndis_init_ops(void);
4564                 driver_ndis_init_ops();
4565         }
4566 #endif /* CONFIG_DRIVER_NDIS */
4567
4568 #ifndef CONFIG_NO_WPA_MSG
4569         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
4570 #endif /* CONFIG_NO_WPA_MSG */
4571
4572         if (params->wpa_debug_file_path)
4573                 wpa_debug_open_file(params->wpa_debug_file_path);
4574         else
4575                 wpa_debug_setup_stdout();
4576         if (params->wpa_debug_syslog)
4577                 wpa_debug_open_syslog();
4578         if (params->wpa_debug_tracing) {
4579                 ret = wpa_debug_open_linux_tracing();
4580                 if (ret) {
4581                         wpa_printf(MSG_ERROR,
4582                                    "Failed to enable trace logging");
4583                         return NULL;
4584                 }
4585         }
4586
4587         ret = eap_register_methods();
4588         if (ret) {
4589                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
4590                 if (ret == -2)
4591                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
4592                                    "the same EAP type.");
4593                 return NULL;
4594         }
4595
4596         global = os_zalloc(sizeof(*global));
4597         if (global == NULL)
4598                 return NULL;
4599         dl_list_init(&global->p2p_srv_bonjour);
4600         dl_list_init(&global->p2p_srv_upnp);
4601         global->params.daemonize = params->daemonize;
4602         global->params.wait_for_monitor = params->wait_for_monitor;
4603         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
4604         if (params->pid_file)
4605                 global->params.pid_file = os_strdup(params->pid_file);
4606         if (params->ctrl_interface)
4607                 global->params.ctrl_interface =
4608                         os_strdup(params->ctrl_interface);
4609         if (params->ctrl_interface_group)
4610                 global->params.ctrl_interface_group =
4611                         os_strdup(params->ctrl_interface_group);
4612         if (params->override_driver)
4613                 global->params.override_driver =
4614                         os_strdup(params->override_driver);
4615         if (params->override_ctrl_interface)
4616                 global->params.override_ctrl_interface =
4617                         os_strdup(params->override_ctrl_interface);
4618         wpa_debug_level = global->params.wpa_debug_level =
4619                 params->wpa_debug_level;
4620         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
4621                 params->wpa_debug_show_keys;
4622         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
4623                 params->wpa_debug_timestamp;
4624
4625         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
4626
4627         if (eloop_init()) {
4628                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
4629                 wpa_supplicant_deinit(global);
4630                 return NULL;
4631         }
4632
4633         random_init(params->entropy_file);
4634
4635         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
4636         if (global->ctrl_iface == NULL) {
4637                 wpa_supplicant_deinit(global);
4638                 return NULL;
4639         }
4640
4641         if (wpas_notify_supplicant_initialized(global)) {
4642                 wpa_supplicant_deinit(global);
4643                 return NULL;
4644         }
4645
4646         for (i = 0; wpa_drivers[i]; i++)
4647                 global->drv_count++;
4648         if (global->drv_count == 0) {
4649                 wpa_printf(MSG_ERROR, "No drivers enabled");
4650                 wpa_supplicant_deinit(global);
4651                 return NULL;
4652         }
4653         global->drv_priv = os_calloc(global->drv_count, sizeof(void *));
4654         if (global->drv_priv == NULL) {
4655                 wpa_supplicant_deinit(global);
4656                 return NULL;
4657         }
4658
4659 #ifdef CONFIG_WIFI_DISPLAY
4660         if (wifi_display_init(global) < 0) {
4661                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
4662                 wpa_supplicant_deinit(global);
4663                 return NULL;
4664         }
4665 #endif /* CONFIG_WIFI_DISPLAY */
4666
4667         return global;
4668 }
4669
4670
4671 /**
4672  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
4673  * @global: Pointer to global data from wpa_supplicant_init()
4674  * Returns: 0 after successful event loop run, -1 on failure
4675  *
4676  * This function starts the main event loop and continues running as long as
4677  * there are any remaining events. In most cases, this function is running as
4678  * long as the %wpa_supplicant process in still in use.
4679  */
4680 int wpa_supplicant_run(struct wpa_global *global)
4681 {
4682         struct wpa_supplicant *wpa_s;
4683
4684         if (global->params.daemonize &&
4685             wpa_supplicant_daemon(global->params.pid_file))
4686                 return -1;
4687
4688         if (global->params.wait_for_monitor) {
4689                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
4690                         if (wpa_s->ctrl_iface)
4691                                 wpa_supplicant_ctrl_iface_wait(
4692                                         wpa_s->ctrl_iface);
4693         }
4694
4695         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
4696         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
4697
4698         eloop_run();
4699
4700         return 0;
4701 }
4702
4703
4704 /**
4705  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
4706  * @global: Pointer to global data from wpa_supplicant_init()
4707  *
4708  * This function is called to deinitialize %wpa_supplicant and to free all
4709  * allocated resources. Remaining network interfaces will also be removed.
4710  */
4711 void wpa_supplicant_deinit(struct wpa_global *global)
4712 {
4713         int i;
4714
4715         if (global == NULL)
4716                 return;
4717
4718 #ifdef CONFIG_WIFI_DISPLAY
4719         wifi_display_deinit(global);
4720 #endif /* CONFIG_WIFI_DISPLAY */
4721
4722         while (global->ifaces)
4723                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
4724
4725         if (global->ctrl_iface)
4726                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
4727
4728         wpas_notify_supplicant_deinitialized(global);
4729
4730         eap_peer_unregister_methods();
4731 #ifdef CONFIG_AP
4732         eap_server_unregister_methods();
4733 #endif /* CONFIG_AP */
4734
4735         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
4736                 if (!global->drv_priv[i])
4737                         continue;
4738                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
4739         }
4740         os_free(global->drv_priv);
4741
4742         random_deinit();
4743
4744         eloop_destroy();
4745
4746         if (global->params.pid_file) {
4747                 os_daemonize_terminate(global->params.pid_file);
4748                 os_free(global->params.pid_file);
4749         }
4750         os_free(global->params.ctrl_interface);
4751         os_free(global->params.ctrl_interface_group);
4752         os_free(global->params.override_driver);
4753         os_free(global->params.override_ctrl_interface);
4754
4755         os_free(global->p2p_disallow_freq.range);
4756         os_free(global->p2p_go_avoid_freq.range);
4757         os_free(global->add_psk);
4758
4759         os_free(global);
4760         wpa_debug_close_syslog();
4761         wpa_debug_close_file();
4762         wpa_debug_close_linux_tracing();
4763 }
4764
4765
4766 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
4767 {
4768         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
4769             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4770                 char country[3];
4771                 country[0] = wpa_s->conf->country[0];
4772                 country[1] = wpa_s->conf->country[1];
4773                 country[2] = '\0';
4774                 if (wpa_drv_set_country(wpa_s, country) < 0) {
4775                         wpa_printf(MSG_ERROR, "Failed to set country code "
4776                                    "'%s'", country);
4777                 }
4778         }
4779
4780         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
4781                 wpas_init_ext_pw(wpa_s);
4782
4783 #ifdef CONFIG_WPS
4784         wpas_wps_update_config(wpa_s);
4785 #endif /* CONFIG_WPS */
4786         wpas_p2p_update_config(wpa_s);
4787         wpa_s->conf->changed_parameters = 0;
4788 }
4789
4790
4791 void add_freq(int *freqs, int *num_freqs, int freq)
4792 {
4793         int i;
4794
4795         for (i = 0; i < *num_freqs; i++) {
4796                 if (freqs[i] == freq)
4797                         return;
4798         }
4799
4800         freqs[*num_freqs] = freq;
4801         (*num_freqs)++;
4802 }
4803
4804
4805 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
4806 {
4807         struct wpa_bss *bss, *cbss;
4808         const int max_freqs = 10;
4809         int *freqs;
4810         int num_freqs = 0;
4811
4812         freqs = os_calloc(max_freqs + 1, sizeof(int));
4813         if (freqs == NULL)
4814                 return NULL;
4815
4816         cbss = wpa_s->current_bss;
4817
4818         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
4819                 if (bss == cbss)
4820                         continue;
4821                 if (bss->ssid_len == cbss->ssid_len &&
4822                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
4823                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
4824                         add_freq(freqs, &num_freqs, bss->freq);
4825                         if (num_freqs == max_freqs)
4826                                 break;
4827                 }
4828         }
4829
4830         if (num_freqs == 0) {
4831                 os_free(freqs);
4832                 freqs = NULL;
4833         }
4834
4835         return freqs;
4836 }
4837
4838
4839 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
4840 {
4841         int timeout;
4842         int count;
4843         int *freqs = NULL;
4844
4845         wpas_connect_work_done(wpa_s);
4846
4847         /*
4848          * Remove possible authentication timeout since the connection failed.
4849          */
4850         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4851
4852         /*
4853          * There is no point in blacklisting the AP if this event is
4854          * generated based on local request to disconnect.
4855          */
4856         if (wpa_s->own_disconnect_req) {
4857                 wpa_s->own_disconnect_req = 0;
4858                 wpa_dbg(wpa_s, MSG_DEBUG,
4859                         "Ignore connection failure due to local request to disconnect");
4860                 return;
4861         }
4862         if (wpa_s->disconnected) {
4863                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
4864                         "indication since interface has been put into "
4865                         "disconnected state");
4866                 return;
4867         }
4868
4869         /*
4870          * Add the failed BSSID into the blacklist and speed up next scan
4871          * attempt if there could be other APs that could accept association.
4872          * The current blacklist count indicates how many times we have tried
4873          * connecting to this AP and multiple attempts mean that other APs are
4874          * either not available or has already been tried, so that we can start
4875          * increasing the delay here to avoid constant scanning.
4876          */
4877         count = wpa_blacklist_add(wpa_s, bssid);
4878         if (count == 1 && wpa_s->current_bss) {
4879                 /*
4880                  * This BSS was not in the blacklist before. If there is
4881                  * another BSS available for the same ESS, we should try that
4882                  * next. Otherwise, we may as well try this one once more
4883                  * before allowing other, likely worse, ESSes to be considered.
4884                  */
4885                 freqs = get_bss_freqs_in_ess(wpa_s);
4886                 if (freqs) {
4887                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
4888                                 "has been seen; try it next");
4889                         wpa_blacklist_add(wpa_s, bssid);
4890                         /*
4891                          * On the next scan, go through only the known channels
4892                          * used in this ESS based on previous scans to speed up
4893                          * common load balancing use case.
4894                          */
4895                         os_free(wpa_s->next_scan_freqs);
4896                         wpa_s->next_scan_freqs = freqs;
4897                 }
4898         }
4899
4900         /*
4901          * Add previous failure count in case the temporary blacklist was
4902          * cleared due to no other BSSes being available.
4903          */
4904         count += wpa_s->extra_blacklist_count;
4905
4906         if (count > 3 && wpa_s->current_ssid) {
4907                 wpa_printf(MSG_DEBUG, "Continuous association failures - "
4908                            "consider temporary network disabling");
4909                 wpas_auth_failed(wpa_s, "CONN_FAILED");
4910         }
4911
4912         switch (count) {
4913         case 1:
4914                 timeout = 100;
4915                 break;
4916         case 2:
4917                 timeout = 500;
4918                 break;
4919         case 3:
4920                 timeout = 1000;
4921                 break;
4922         case 4:
4923                 timeout = 5000;
4924                 break;
4925         default:
4926                 timeout = 10000;
4927                 break;
4928         }
4929
4930         wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
4931                 "ms", count, timeout);
4932
4933         /*
4934          * TODO: if more than one possible AP is available in scan results,
4935          * could try the other ones before requesting a new scan.
4936          */
4937         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
4938                                 1000 * (timeout % 1000));
4939 }
4940
4941
4942 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
4943 {
4944         return wpa_s->conf->ap_scan == 2 ||
4945                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
4946 }
4947
4948
4949 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
4950 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
4951                                               struct wpa_ssid *ssid,
4952                                               const char *field,
4953                                               const char *value)
4954 {
4955 #ifdef IEEE8021X_EAPOL
4956         struct eap_peer_config *eap = &ssid->eap;
4957
4958         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
4959         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
4960                               (const u8 *) value, os_strlen(value));
4961
4962         switch (wpa_supplicant_ctrl_req_from_string(field)) {
4963         case WPA_CTRL_REQ_EAP_IDENTITY:
4964                 os_free(eap->identity);
4965                 eap->identity = (u8 *) os_strdup(value);
4966                 eap->identity_len = os_strlen(value);
4967                 eap->pending_req_identity = 0;
4968                 if (ssid == wpa_s->current_ssid)
4969                         wpa_s->reassociate = 1;
4970                 break;
4971         case WPA_CTRL_REQ_EAP_PASSWORD:
4972                 bin_clear_free(eap->password, eap->password_len);
4973                 eap->password = (u8 *) os_strdup(value);
4974                 eap->password_len = os_strlen(value);
4975                 eap->pending_req_password = 0;
4976                 if (ssid == wpa_s->current_ssid)
4977                         wpa_s->reassociate = 1;
4978                 break;
4979         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
4980                 bin_clear_free(eap->new_password, eap->new_password_len);
4981                 eap->new_password = (u8 *) os_strdup(value);
4982                 eap->new_password_len = os_strlen(value);
4983                 eap->pending_req_new_password = 0;
4984                 if (ssid == wpa_s->current_ssid)
4985                         wpa_s->reassociate = 1;
4986                 break;
4987         case WPA_CTRL_REQ_EAP_PIN:
4988                 str_clear_free(eap->pin);
4989                 eap->pin = os_strdup(value);
4990                 eap->pending_req_pin = 0;
4991                 if (ssid == wpa_s->current_ssid)
4992                         wpa_s->reassociate = 1;
4993                 break;
4994         case WPA_CTRL_REQ_EAP_OTP:
4995                 bin_clear_free(eap->otp, eap->otp_len);
4996                 eap->otp = (u8 *) os_strdup(value);
4997                 eap->otp_len = os_strlen(value);
4998                 os_free(eap->pending_req_otp);
4999                 eap->pending_req_otp = NULL;
5000                 eap->pending_req_otp_len = 0;
5001                 break;
5002         case WPA_CTRL_REQ_EAP_PASSPHRASE:
5003                 str_clear_free(eap->private_key_passwd);
5004                 eap->private_key_passwd = os_strdup(value);
5005                 eap->pending_req_passphrase = 0;
5006                 if (ssid == wpa_s->current_ssid)
5007                         wpa_s->reassociate = 1;
5008                 break;
5009         case WPA_CTRL_REQ_SIM:
5010                 str_clear_free(eap->external_sim_resp);
5011                 eap->external_sim_resp = os_strdup(value);
5012                 break;
5013         case WPA_CTRL_REQ_PSK_PASSPHRASE:
5014                 if (wpa_config_set(ssid, "psk", value, 0) < 0)
5015                         return -1;
5016                 ssid->mem_only_psk = 1;
5017                 if (ssid->passphrase)
5018                         wpa_config_update_psk(ssid);
5019                 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
5020                         wpa_supplicant_req_scan(wpa_s, 0, 0);
5021                 break;
5022         default:
5023                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
5024                 return -1;
5025         }
5026
5027         return 0;
5028 #else /* IEEE8021X_EAPOL */
5029         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
5030         return -1;
5031 #endif /* IEEE8021X_EAPOL */
5032 }
5033 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
5034
5035
5036 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5037 {
5038         int i;
5039         unsigned int drv_enc;
5040
5041         if (wpa_s->p2p_mgmt)
5042                 return 1; /* no normal network profiles on p2p_mgmt interface */
5043
5044         if (ssid == NULL)
5045                 return 1;
5046
5047         if (ssid->disabled)
5048                 return 1;
5049
5050         if (wpa_s->drv_capa_known)
5051                 drv_enc = wpa_s->drv_enc;
5052         else
5053                 drv_enc = (unsigned int) -1;
5054
5055         for (i = 0; i < NUM_WEP_KEYS; i++) {
5056                 size_t len = ssid->wep_key_len[i];
5057                 if (len == 0)
5058                         continue;
5059                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
5060                         continue;
5061                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
5062                         continue;
5063                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
5064                         continue;
5065                 return 1; /* invalid WEP key */
5066         }
5067
5068         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
5069             (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk &&
5070             !ssid->mem_only_psk)
5071                 return 1;
5072
5073         return 0;
5074 }
5075
5076
5077 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5078 {
5079 #ifdef CONFIG_IEEE80211W
5080         if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) {
5081                 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
5082                     !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
5083                         /*
5084                          * Driver does not support BIP -- ignore pmf=1 default
5085                          * since the connection with PMF would fail and the
5086                          * configuration does not require PMF to be enabled.
5087                          */
5088                         return NO_MGMT_FRAME_PROTECTION;
5089                 }
5090
5091                 return wpa_s->conf->pmf;
5092         }
5093
5094         return ssid->ieee80211w;
5095 #else /* CONFIG_IEEE80211W */
5096         return NO_MGMT_FRAME_PROTECTION;
5097 #endif /* CONFIG_IEEE80211W */
5098 }
5099
5100
5101 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
5102 {
5103         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
5104                 return 1;
5105         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
5106                 return 0;
5107         return -1;
5108 }
5109
5110
5111 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
5112 {
5113         struct wpa_ssid *ssid = wpa_s->current_ssid;
5114         int dur;
5115         struct os_reltime now;
5116
5117         if (ssid == NULL) {
5118                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
5119                            "SSID block");
5120                 return;
5121         }
5122
5123         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
5124                 return;
5125
5126         ssid->auth_failures++;
5127
5128 #ifdef CONFIG_P2P
5129         if (ssid->p2p_group &&
5130             (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
5131                 /*
5132                  * Skip the wait time since there is a short timeout on the
5133                  * connection to a P2P group.
5134                  */
5135                 return;
5136         }
5137 #endif /* CONFIG_P2P */
5138
5139         if (ssid->auth_failures > 50)
5140                 dur = 300;
5141         else if (ssid->auth_failures > 10)
5142                 dur = 120;
5143         else if (ssid->auth_failures > 5)
5144                 dur = 90;
5145         else if (ssid->auth_failures > 3)
5146                 dur = 60;
5147         else if (ssid->auth_failures > 2)
5148                 dur = 30;
5149         else if (ssid->auth_failures > 1)
5150                 dur = 20;
5151         else
5152                 dur = 10;
5153
5154         if (ssid->auth_failures > 1 &&
5155             wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
5156                 dur += os_random() % (ssid->auth_failures * 10);
5157
5158         os_get_reltime(&now);
5159         if (now.sec + dur <= ssid->disabled_until.sec)
5160                 return;
5161
5162         ssid->disabled_until.sec = now.sec + dur;
5163
5164         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
5165                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
5166                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
5167                 ssid->auth_failures, dur, reason);
5168 }
5169
5170
5171 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
5172                               struct wpa_ssid *ssid, int clear_failures)
5173 {
5174         if (ssid == NULL)
5175                 return;
5176
5177         if (ssid->disabled_until.sec) {
5178                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
5179                         "id=%d ssid=\"%s\"",
5180                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
5181         }
5182         ssid->disabled_until.sec = 0;
5183         ssid->disabled_until.usec = 0;
5184         if (clear_failures)
5185                 ssid->auth_failures = 0;
5186 }
5187
5188
5189 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
5190 {
5191         size_t i;
5192
5193         if (wpa_s->disallow_aps_bssid == NULL)
5194                 return 0;
5195
5196         for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
5197                 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
5198                               bssid, ETH_ALEN) == 0)
5199                         return 1;
5200         }
5201
5202         return 0;
5203 }
5204
5205
5206 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
5207                     size_t ssid_len)
5208 {
5209         size_t i;
5210
5211         if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
5212                 return 0;
5213
5214         for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
5215                 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
5216                 if (ssid_len == s->ssid_len &&
5217                     os_memcmp(ssid, s->ssid, ssid_len) == 0)
5218                         return 1;
5219         }
5220
5221         return 0;
5222 }
5223
5224
5225 /**
5226  * wpas_request_connection - Request a new connection
5227  * @wpa_s: Pointer to the network interface
5228  *
5229  * This function is used to request a new connection to be found. It will mark
5230  * the interface to allow reassociation and request a new scan to find a
5231  * suitable network to connect to.
5232  */
5233 void wpas_request_connection(struct wpa_supplicant *wpa_s)
5234 {
5235         wpa_s->normal_scans = 0;
5236         wpa_s->scan_req = NORMAL_SCAN_REQ;
5237         wpa_supplicant_reinit_autoscan(wpa_s);
5238         wpa_s->extra_blacklist_count = 0;
5239         wpa_s->disconnected = 0;
5240         wpa_s->reassociate = 1;
5241
5242         if (wpa_supplicant_fast_associate(wpa_s) != 1)
5243                 wpa_supplicant_req_scan(wpa_s, 0, 0);
5244         else
5245                 wpa_s->reattach = 0;
5246 }
5247
5248
5249 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
5250                     struct wpa_used_freq_data *freqs_data,
5251                     unsigned int len)
5252 {
5253         unsigned int i;
5254
5255         wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
5256                 len, title);
5257         for (i = 0; i < len; i++) {
5258                 struct wpa_used_freq_data *cur = &freqs_data[i];
5259                 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
5260                         i, cur->freq, cur->flags);
5261         }
5262 }
5263
5264
5265 /*
5266  * Find the operating frequencies of any of the virtual interfaces that
5267  * are using the same radio as the current interface, and in addition, get
5268  * information about the interface types that are using the frequency.
5269  */
5270 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
5271                                 struct wpa_used_freq_data *freqs_data,
5272                                 unsigned int len)
5273 {
5274         struct wpa_supplicant *ifs;
5275         u8 bssid[ETH_ALEN];
5276         int freq;
5277         unsigned int idx = 0, i;
5278
5279         wpa_dbg(wpa_s, MSG_DEBUG,
5280                 "Determining shared radio frequencies (max len %u)", len);
5281         os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
5282
5283         dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
5284                          radio_list) {
5285                 if (idx == len)
5286                         break;
5287
5288                 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
5289                         continue;
5290
5291                 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
5292                     ifs->current_ssid->mode == WPAS_MODE_P2P_GO)
5293                         freq = ifs->current_ssid->frequency;
5294                 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
5295                         freq = ifs->assoc_freq;
5296                 else
5297                         continue;
5298
5299                 /* Hold only distinct freqs */
5300                 for (i = 0; i < idx; i++)
5301                         if (freqs_data[i].freq == freq)
5302                                 break;
5303
5304                 if (i == idx)
5305                         freqs_data[idx++].freq = freq;
5306
5307                 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
5308                         freqs_data[i].flags = ifs->current_ssid->p2p_group ?
5309                                 WPA_FREQ_USED_BY_P2P_CLIENT :
5310                                 WPA_FREQ_USED_BY_INFRA_STATION;
5311                 }
5312         }
5313
5314         dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
5315         return idx;
5316 }
5317
5318
5319 /*
5320  * Find the operating frequencies of any of the virtual interfaces that
5321  * are using the same radio as the current interface.
5322  */
5323 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
5324                            int *freq_array, unsigned int len)
5325 {
5326         struct wpa_used_freq_data *freqs_data;
5327         int num, i;
5328
5329         os_memset(freq_array, 0, sizeof(int) * len);
5330
5331         freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
5332         if (!freqs_data)
5333                 return -1;
5334
5335         num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
5336         for (i = 0; i < num; i++)
5337                 freq_array[i] = freqs_data[i].freq;
5338
5339         os_free(freqs_data);
5340
5341         return num;
5342 }
5343
5344
5345 static void wpas_rrm_neighbor_rep_timeout_handler(void *data, void *user_ctx)
5346 {
5347         struct rrm_data *rrm = data;
5348
5349         if (!rrm->notify_neighbor_rep) {
5350                 wpa_printf(MSG_ERROR,
5351                            "RRM: Unexpected neighbor report timeout");
5352                 return;
5353         }
5354
5355         wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report - NONE");
5356         rrm->notify_neighbor_rep(rrm->neighbor_rep_cb_ctx, NULL);
5357
5358         rrm->notify_neighbor_rep = NULL;
5359         rrm->neighbor_rep_cb_ctx = NULL;
5360 }
5361
5362
5363 /*
5364  * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant
5365  * @wpa_s: Pointer to wpa_supplicant
5366  */
5367 void wpas_rrm_reset(struct wpa_supplicant *wpa_s)
5368 {
5369         wpa_s->rrm.rrm_used = 0;
5370
5371         eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
5372                              NULL);
5373         if (wpa_s->rrm.notify_neighbor_rep)
5374                 wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL);
5375         wpa_s->rrm.next_neighbor_rep_token = 1;
5376 }
5377
5378
5379 /*
5380  * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
5381  * @wpa_s: Pointer to wpa_supplicant
5382  * @report: Neighbor report buffer, prefixed by a 1-byte dialog token
5383  * @report_len: Length of neighbor report buffer
5384  */
5385 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s,
5386                                    const u8 *report, size_t report_len)
5387 {
5388         struct wpabuf *neighbor_rep;
5389
5390         wpa_hexdump(MSG_DEBUG, "RRM: New Neighbor Report", report, report_len);
5391         if (report_len < 1)
5392                 return;
5393
5394         if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
5395                 wpa_printf(MSG_DEBUG,
5396                            "RRM: Discarding neighbor report with token %d (expected %d)",
5397                            report[0], wpa_s->rrm.next_neighbor_rep_token - 1);
5398                 return;
5399         }
5400
5401         eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
5402                              NULL);
5403
5404         if (!wpa_s->rrm.notify_neighbor_rep) {
5405                 wpa_printf(MSG_ERROR, "RRM: Unexpected neighbor report");
5406                 return;
5407         }
5408
5409         /* skipping the first byte, which is only an id (dialog token) */
5410         neighbor_rep = wpabuf_alloc(report_len - 1);
5411         if (neighbor_rep == NULL)
5412                 return;
5413         wpabuf_put_data(neighbor_rep, report + 1, report_len - 1);
5414         wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)",
5415                    report[0]);
5416         wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
5417                                        neighbor_rep);
5418         wpa_s->rrm.notify_neighbor_rep = NULL;
5419         wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
5420 }
5421
5422
5423 #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
5424 /* Workaround different, undefined for Windows, error codes used here */
5425 #define ENOTCONN -1
5426 #define EOPNOTSUPP -1
5427 #define ECANCELED -1
5428 #endif
5429
5430 /**
5431  * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP
5432  * @wpa_s: Pointer to wpa_supplicant
5433  * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE
5434  *        is sent in the request.
5435  * @cb: Callback function to be called once the requested report arrives, or
5436  *      timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds.
5437  *      In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's
5438  *      the requester's responsibility to free it.
5439  *      In the latter case NULL will be sent in 'neighbor_rep'.
5440  * @cb_ctx: Context value to send the callback function
5441  * Returns: 0 in case of success, negative error code otherwise
5442  *
5443  * In case there is a previous request which has not been answered yet, the
5444  * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT.
5445  * Request must contain a callback function.
5446  */
5447 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s,
5448                                        const struct wpa_ssid *ssid,
5449                                        void (*cb)(void *ctx,
5450                                                   struct wpabuf *neighbor_rep),
5451                                        void *cb_ctx)
5452 {
5453         struct wpabuf *buf;
5454         const u8 *rrm_ie;
5455
5456         if (wpa_s->wpa_state != WPA_COMPLETED || wpa_s->current_ssid == NULL) {
5457                 wpa_printf(MSG_DEBUG, "RRM: No connection, no RRM.");
5458                 return -ENOTCONN;
5459         }
5460
5461         if (!wpa_s->rrm.rrm_used) {
5462                 wpa_printf(MSG_DEBUG, "RRM: No RRM in current connection.");
5463                 return -EOPNOTSUPP;
5464         }
5465
5466         rrm_ie = wpa_bss_get_ie(wpa_s->current_bss,
5467                                 WLAN_EID_RRM_ENABLED_CAPABILITIES);
5468         if (!rrm_ie || !(wpa_s->current_bss->caps & IEEE80211_CAP_RRM) ||
5469             !(rrm_ie[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
5470                 wpa_printf(MSG_DEBUG,
5471                            "RRM: No network support for Neighbor Report.");
5472                 return -EOPNOTSUPP;
5473         }
5474
5475         if (!cb) {
5476                 wpa_printf(MSG_DEBUG,
5477                            "RRM: Neighbor Report request must provide a callback.");
5478                 return -EINVAL;
5479         }
5480
5481         /* Refuse if there's a live request */
5482         if (wpa_s->rrm.notify_neighbor_rep) {
5483                 wpa_printf(MSG_DEBUG,
5484                            "RRM: Currently handling previous Neighbor Report.");
5485                 return -EBUSY;
5486         }
5487
5488         /* 3 = action category + action code + dialog token */
5489         buf = wpabuf_alloc(3 + (ssid ? 2 + ssid->ssid_len : 0));
5490         if (buf == NULL) {
5491                 wpa_printf(MSG_DEBUG,
5492                            "RRM: Failed to allocate Neighbor Report Request");
5493                 return -ENOMEM;
5494         }
5495
5496         wpa_printf(MSG_DEBUG, "RRM: Neighbor report request (for %s), token=%d",
5497                    (ssid ? wpa_ssid_txt(ssid->ssid, ssid->ssid_len) : ""),
5498                    wpa_s->rrm.next_neighbor_rep_token);
5499
5500         wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
5501         wpabuf_put_u8(buf, WLAN_RRM_NEIGHBOR_REPORT_REQUEST);
5502         wpabuf_put_u8(buf, wpa_s->rrm.next_neighbor_rep_token);
5503         if (ssid) {
5504                 wpabuf_put_u8(buf, WLAN_EID_SSID);
5505                 wpabuf_put_u8(buf, ssid->ssid_len);
5506                 wpabuf_put_data(buf, ssid->ssid, ssid->ssid_len);
5507         }
5508
5509         wpa_s->rrm.next_neighbor_rep_token++;
5510
5511         if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
5512                                 wpa_s->own_addr, wpa_s->bssid,
5513                                 wpabuf_head(buf), wpabuf_len(buf), 0) < 0) {
5514                 wpa_printf(MSG_DEBUG,
5515                            "RRM: Failed to send Neighbor Report Request");
5516                 wpabuf_free(buf);
5517                 return -ECANCELED;
5518         }
5519
5520         wpa_s->rrm.neighbor_rep_cb_ctx = cb_ctx;
5521         wpa_s->rrm.notify_neighbor_rep = cb;
5522         eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT, 0,
5523                                wpas_rrm_neighbor_rep_timeout_handler,
5524                                &wpa_s->rrm, NULL);
5525
5526         wpabuf_free(buf);
5527         return 0;
5528 }
5529
5530
5531 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s,
5532                                               const u8 *src,
5533                                               const u8 *frame, size_t len,
5534                                               int rssi)
5535 {
5536         struct wpabuf *buf;
5537         const struct rrm_link_measurement_request *req;
5538         struct rrm_link_measurement_report report;
5539
5540         if (wpa_s->wpa_state != WPA_COMPLETED) {
5541                 wpa_printf(MSG_INFO,
5542                            "RRM: Ignoring link measurement request. Not associated");
5543                 return;
5544         }
5545
5546         if (!wpa_s->rrm.rrm_used) {
5547                 wpa_printf(MSG_INFO,
5548                            "RRM: Ignoring link measurement request. Not RRM network");
5549                 return;
5550         }
5551
5552         if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION)) {
5553                 wpa_printf(MSG_INFO,
5554                            "RRM: Measurement report failed. TX power insertion not supported");
5555                 return;
5556         }
5557
5558         req = (const struct rrm_link_measurement_request *) frame;
5559         if (len < sizeof(*req)) {
5560                 wpa_printf(MSG_INFO,
5561                            "RRM: Link measurement report failed. Request too short");
5562                 return;
5563         }
5564
5565         os_memset(&report, 0, sizeof(report));
5566         report.tpc.eid = WLAN_EID_TPC_REPORT;
5567         report.tpc.len = 2;
5568         report.rsni = 255; /* 255 indicates that RSNI is not available */
5569         report.dialog_token = req->dialog_token;
5570
5571         /*
5572          * It's possible to estimate RCPI based on RSSI in dBm. This
5573          * calculation will not reflect the correct value for high rates,
5574          * but it's good enough for Action frames which are transmitted
5575          * with up to 24 Mbps rates.
5576          */
5577         if (!rssi)
5578                 report.rcpi = 255; /* not available */
5579         else if (rssi < -110)
5580                 report.rcpi = 0;
5581         else if (rssi > 0)
5582                 report.rcpi = 220;
5583         else
5584                 report.rcpi = (rssi + 110) * 2;
5585
5586         /* action_category + action_code */
5587         buf = wpabuf_alloc(2 + sizeof(report));
5588         if (buf == NULL) {
5589                 wpa_printf(MSG_ERROR,
5590                            "RRM: Link measurement report failed. Buffer allocation failed");
5591                 return;
5592         }
5593
5594         wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
5595         wpabuf_put_u8(buf, WLAN_RRM_LINK_MEASUREMENT_REPORT);
5596         wpabuf_put_data(buf, &report, sizeof(report));
5597         wpa_hexdump(MSG_DEBUG, "RRM: Link measurement report:",
5598                     wpabuf_head(buf), wpabuf_len(buf));
5599
5600         if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
5601                                 wpa_s->own_addr, wpa_s->bssid,
5602                                 wpabuf_head(buf), wpabuf_len(buf), 0)) {
5603                 wpa_printf(MSG_ERROR,
5604                            "RRM: Link measurement report failed. Send action failed");
5605         }
5606         wpabuf_free(buf);
5607 }