wpa_supplicant/wpa_supplicant.c

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