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 &&
1615             (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
1616 #ifdef CONFIG_IEEE80211R
1617                 const u8 *ie, *md = NULL;
1618 #endif /* CONFIG_IEEE80211R */
1619                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1620                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1621                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1622                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1623                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1624                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1625                 if (bssid_changed)
1626                         wpas_notify_bssid_changed(wpa_s);
1627 #ifdef CONFIG_IEEE80211R
1628                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1629                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1630                         md = ie + 2;
1631                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1632                 if (md) {
1633                         /* Prepare for the next transition */
1634                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1635                 }
1636 #endif /* CONFIG_IEEE80211R */
1637 #ifdef CONFIG_WPS
1638         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1639                    wpa_s->conf->ap_scan == 2 &&
1640                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1641                 /* Use ap_scan==1 style network selection to find the network
1642                  */
1643                 wpas_connect_work_done(wpa_s);
1644                 wpa_s->scan_req = MANUAL_SCAN_REQ;
1645                 wpa_s->reassociate = 1;
1646                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1647                 return;
1648 #endif /* CONFIG_WPS */
1649         } else {
1650                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1651                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1652                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1653         }
1654         wpa_supplicant_cancel_sched_scan(wpa_s);
1655         wpa_supplicant_cancel_scan(wpa_s);
1656
1657         /* Starting new association, so clear the possibly used WPA IE from the
1658          * previous association. */
1659         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1660
1661 #ifdef IEEE8021X_EAPOL
1662         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1663                 if (ssid->leap) {
1664                         if (ssid->non_leap == 0)
1665                                 algs = WPA_AUTH_ALG_LEAP;
1666                         else
1667                                 algs |= WPA_AUTH_ALG_LEAP;
1668                 }
1669         }
1670 #endif /* IEEE8021X_EAPOL */
1671         wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1672         if (ssid->auth_alg) {
1673                 algs = ssid->auth_alg;
1674                 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1675                         "0x%x", algs);
1676         }
1677
1678         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1679                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
1680             wpa_key_mgmt_wpa(ssid->key_mgmt)) {
1681                 int try_opportunistic;
1682                 try_opportunistic = (ssid->proactive_key_caching < 0 ?
1683                                      wpa_s->conf->okc :
1684                                      ssid->proactive_key_caching) &&
1685                         (ssid->proto & WPA_PROTO_RSN);
1686                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1687                                             ssid, try_opportunistic) == 0)
1688                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1689                 wpa_ie_len = sizeof(wpa_ie);
1690                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1691                                               wpa_ie, &wpa_ie_len)) {
1692                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1693                                 "key management and encryption suites");
1694                         wpas_connect_work_done(wpa_s);
1695                         return;
1696                 }
1697         } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
1698                    wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
1699                 /*
1700                  * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1701                  * use non-WPA since the scan results did not indicate that the
1702                  * AP is using WPA or WPA2.
1703                  */
1704                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1705                 wpa_ie_len = 0;
1706                 wpa_s->wpa_proto = 0;
1707         } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
1708                 wpa_ie_len = sizeof(wpa_ie);
1709                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1710                                               wpa_ie, &wpa_ie_len)) {
1711                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1712                                 "key management and encryption suites (no "
1713                                 "scan results)");
1714                         wpas_connect_work_done(wpa_s);
1715                         return;
1716                 }
1717 #ifdef CONFIG_WPS
1718         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1719                 struct wpabuf *wps_ie;
1720                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1721                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1722                         wpa_ie_len = wpabuf_len(wps_ie);
1723                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1724                 } else
1725                         wpa_ie_len = 0;
1726                 wpabuf_free(wps_ie);
1727                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1728                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1729                         params.wps = WPS_MODE_PRIVACY;
1730                 else
1731                         params.wps = WPS_MODE_OPEN;
1732                 wpa_s->wpa_proto = 0;
1733 #endif /* CONFIG_WPS */
1734         } else {
1735                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1736                 wpa_ie_len = 0;
1737                 wpa_s->wpa_proto = 0;
1738         }
1739
1740 #ifdef CONFIG_P2P
1741         if (wpa_s->global->p2p) {
1742                 u8 *pos;
1743                 size_t len;
1744                 int res;
1745                 pos = wpa_ie + wpa_ie_len;
1746                 len = sizeof(wpa_ie) - wpa_ie_len;
1747                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1748                                             ssid->p2p_group);
1749                 if (res >= 0)
1750                         wpa_ie_len += res;
1751         }
1752
1753         wpa_s->cross_connect_disallowed = 0;
1754         if (bss) {
1755                 struct wpabuf *p2p;
1756                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1757                 if (p2p) {
1758                         wpa_s->cross_connect_disallowed =
1759                                 p2p_get_cross_connect_disallowed(p2p);
1760                         wpabuf_free(p2p);
1761                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1762                                 "connection",
1763                                 wpa_s->cross_connect_disallowed ?
1764                                 "disallows" : "allows");
1765                 }
1766         }
1767
1768         os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
1769 #endif /* CONFIG_P2P */
1770
1771 #ifdef CONFIG_HS20
1772         if (is_hs20_network(wpa_s, ssid, bss)) {
1773                 struct wpabuf *hs20;
1774                 hs20 = wpabuf_alloc(20);
1775                 if (hs20) {
1776                         int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
1777                         size_t len;
1778
1779                         wpas_hs20_add_indication(hs20, pps_mo_id);
1780                         len = sizeof(wpa_ie) - wpa_ie_len;
1781                         if (wpabuf_len(hs20) <= len) {
1782                                 os_memcpy(wpa_ie + wpa_ie_len,
1783                                           wpabuf_head(hs20), wpabuf_len(hs20));
1784                                 wpa_ie_len += wpabuf_len(hs20);
1785                         }
1786                         wpabuf_free(hs20);
1787                 }
1788         }
1789 #endif /* CONFIG_HS20 */
1790
1791         /*
1792          * Workaround: Add Extended Capabilities element only if the AP
1793          * included this element in Beacon/Probe Response frames. Some older
1794          * APs seem to have interoperability issues if this element is
1795          * included, so while the standard may require us to include the
1796          * element in all cases, it is justifiable to skip it to avoid
1797          * interoperability issues.
1798          */
1799         if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
1800                 u8 ext_capab[18];
1801                 int ext_capab_len;
1802                 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
1803                                                      sizeof(ext_capab));
1804                 if (ext_capab_len > 0) {
1805                         u8 *pos = wpa_ie;
1806                         if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
1807                                 pos += 2 + pos[1];
1808                         os_memmove(pos + ext_capab_len, pos,
1809                                    wpa_ie_len - (pos - wpa_ie));
1810                         wpa_ie_len += ext_capab_len;
1811                         os_memcpy(pos, ext_capab, ext_capab_len);
1812                 }
1813         }
1814
1815         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1816         use_crypt = 1;
1817         cipher_pairwise = wpa_s->pairwise_cipher;
1818         cipher_group = wpa_s->group_cipher;
1819         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1820             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1821                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1822                         use_crypt = 0;
1823                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1824                         use_crypt = 1;
1825                         wep_keys_set = 1;
1826                 }
1827         }
1828         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1829                 use_crypt = 0;
1830
1831 #ifdef IEEE8021X_EAPOL
1832         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1833                 if ((ssid->eapol_flags &
1834                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1835                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1836                     !wep_keys_set) {
1837                         use_crypt = 0;
1838                 } else {
1839                         /* Assume that dynamic WEP-104 keys will be used and
1840                          * set cipher suites in order for drivers to expect
1841                          * encryption. */
1842                         cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
1843                 }
1844         }
1845 #endif /* IEEE8021X_EAPOL */
1846
1847         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1848                 /* Set the key before (and later after) association */
1849                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1850         }
1851
1852         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1853         if (bss) {
1854                 params.ssid = bss->ssid;
1855                 params.ssid_len = bss->ssid_len;
1856                 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1857                         wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
1858                                    MACSTR " freq=%u MHz based on scan results "
1859                                    "(bssid_set=%d)",
1860                                    MAC2STR(bss->bssid), bss->freq,
1861                                    ssid->bssid_set);
1862                         params.bssid = bss->bssid;
1863                         params.freq.freq = bss->freq;
1864                 }
1865                 params.bssid_hint = bss->bssid;
1866                 params.freq_hint = bss->freq;
1867         } else {
1868                 params.ssid = ssid->ssid;
1869                 params.ssid_len = ssid->ssid_len;
1870         }
1871
1872         if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
1873             wpa_s->conf->ap_scan == 2) {
1874                 params.bssid = ssid->bssid;
1875                 params.fixed_bssid = 1;
1876         }
1877
1878         if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1879             params.freq.freq == 0) {
1880                 enum hostapd_hw_mode hw_mode;
1881                 u8 channel;
1882
1883                 params.freq.freq = ssid->frequency;
1884
1885                 hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel);
1886                 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1887                         if (wpa_s->hw.modes[i].mode == hw_mode) {
1888                                 struct hostapd_hw_modes *mode;
1889
1890                                 mode = &wpa_s->hw.modes[i];
1891                                 params.freq.ht_enabled = ht_supported(mode);
1892                                 break;
1893                         }
1894                 }
1895         }
1896
1897         if (ssid->mode == WPAS_MODE_IBSS) {
1898                 if (ssid->beacon_int)
1899                         params.beacon_int = ssid->beacon_int;
1900                 else
1901                         params.beacon_int = wpa_s->conf->beacon_int;
1902         }
1903
1904         params.wpa_ie = wpa_ie;
1905         params.wpa_ie_len = wpa_ie_len;
1906         params.pairwise_suite = cipher_pairwise;
1907         params.group_suite = cipher_group;
1908         params.key_mgmt_suite = wpa_s->key_mgmt;
1909         params.wpa_proto = wpa_s->wpa_proto;
1910         params.auth_alg = algs;
1911         params.mode = ssid->mode;
1912         params.bg_scan_period = ssid->bg_scan_period;
1913         for (i = 0; i < NUM_WEP_KEYS; i++) {
1914                 if (ssid->wep_key_len[i])
1915                         params.wep_key[i] = ssid->wep_key[i];
1916                 params.wep_key_len[i] = ssid->wep_key_len[i];
1917         }
1918         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1919
1920         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1921             (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
1922              params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
1923                 params.passphrase = ssid->passphrase;
1924                 if (ssid->psk_set)
1925                         params.psk = ssid->psk;
1926         }
1927
1928         if (wpa_s->conf->key_mgmt_offload) {
1929                 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
1930                     params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256)
1931                         params.req_key_mgmt_offload =
1932                                 ssid->proactive_key_caching < 0 ?
1933                                 wpa_s->conf->okc : ssid->proactive_key_caching;
1934                 else
1935                         params.req_key_mgmt_offload = 1;
1936
1937                 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
1938                      params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
1939                      params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
1940                     ssid->psk_set)
1941                         params.psk = ssid->psk;
1942         }
1943
1944         params.drop_unencrypted = use_crypt;
1945
1946 #ifdef CONFIG_IEEE80211W
1947         params.mgmt_frame_protection =
1948                 ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1949                 wpa_s->conf->pmf : ssid->ieee80211w;
1950         if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
1951                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1952                 struct wpa_ie_data ie;
1953                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1954                     ie.capabilities &
1955                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1956                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1957                                 "MFP: require MFP");
1958                         params.mgmt_frame_protection =
1959                                 MGMT_FRAME_PROTECTION_REQUIRED;
1960                 }
1961         }
1962 #endif /* CONFIG_IEEE80211W */
1963
1964         params.p2p = ssid->p2p_group;
1965
1966         if (wpa_s->parent->set_sta_uapsd)
1967                 params.uapsd = wpa_s->parent->sta_uapsd;
1968         else
1969                 params.uapsd = -1;
1970
1971 #ifdef CONFIG_HT_OVERRIDES
1972         os_memset(&htcaps, 0, sizeof(htcaps));
1973         os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
1974         params.htcaps = (u8 *) &htcaps;
1975         params.htcaps_mask = (u8 *) &htcaps_mask;
1976         wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
1977 #endif /* CONFIG_HT_OVERRIDES */
1978 #ifdef CONFIG_VHT_OVERRIDES
1979         os_memset(&vhtcaps, 0, sizeof(vhtcaps));
1980         os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
1981         params.vhtcaps = &vhtcaps;
1982         params.vhtcaps_mask = &vhtcaps_mask;
1983         wpa_supplicant_apply_vht_overrides(wpa_s, wpa_s->current_ssid, &params);
1984 #endif /* CONFIG_VHT_OVERRIDES */
1985
1986 #ifdef CONFIG_P2P
1987         /*
1988          * If multi-channel concurrency is not supported, check for any
1989          * frequency conflict. In case of any frequency conflict, remove the
1990          * least prioritized connection.
1991          */
1992         if (wpa_s->num_multichan_concurrent < 2) {
1993                 int freq, num;
1994                 num = get_shared_radio_freqs(wpa_s, &freq, 1);
1995                 if (num > 0 && freq > 0 && freq != params.freq.freq) {
1996                         wpa_printf(MSG_DEBUG,
1997                                    "Assoc conflicting freq found (%d != %d)",
1998                                    freq, params.freq.freq);
1999                         if (wpas_p2p_handle_frequency_conflicts(
2000                                     wpa_s, params.freq.freq, ssid) < 0) {
2001                                 wpas_connect_work_done(wpa_s);
2002                                 return;
2003                         }
2004                 }
2005         }
2006 #endif /* CONFIG_P2P */
2007
2008         ret = wpa_drv_associate(wpa_s, &params);
2009         if (ret < 0) {
2010                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2011                         "failed");
2012                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2013                         /*
2014                          * The driver is known to mean what is saying, so we
2015                          * can stop right here; the association will not
2016                          * succeed.
2017                          */
2018                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2019                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2020                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2021                         return;
2022                 }
2023                 /* try to continue anyway; new association will be tried again
2024                  * after timeout */
2025                 assoc_failed = 1;
2026         }
2027
2028         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2029                 /* Set the key after the association just in case association
2030                  * cleared the previously configured key. */
2031                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2032                 /* No need to timeout authentication since there is no key
2033                  * management. */
2034                 wpa_supplicant_cancel_auth_timeout(wpa_s);
2035                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2036 #ifdef CONFIG_IBSS_RSN
2037         } else if (ssid->mode == WPAS_MODE_IBSS &&
2038                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2039                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2040                 /*
2041                  * RSN IBSS authentication is per-STA and we can disable the
2042                  * per-BSSID authentication.
2043                  */
2044                 wpa_supplicant_cancel_auth_timeout(wpa_s);
2045 #endif /* CONFIG_IBSS_RSN */
2046         } else {
2047                 /* Timeout for IEEE 802.11 authentication and association */
2048                 int timeout = 60;
2049
2050                 if (assoc_failed) {
2051                         /* give IBSS a bit more time */
2052                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2053                 } else if (wpa_s->conf->ap_scan == 1) {
2054                         /* give IBSS a bit more time */
2055                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2056                 }
2057                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2058         }
2059
2060         if (wep_keys_set &&
2061             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2062                 /* Set static WEP keys again */
2063                 wpa_set_wep_keys(wpa_s, ssid);
2064         }
2065
2066         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2067                 /*
2068                  * Do not allow EAP session resumption between different
2069                  * network configurations.
2070                  */
2071                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2072         }
2073         old_ssid = wpa_s->current_ssid;
2074         wpa_s->current_ssid = ssid;
2075         wpa_s->current_bss = bss;
2076         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2077         wpa_supplicant_initiate_eapol(wpa_s);
2078         if (old_ssid != wpa_s->current_ssid)
2079                 wpas_notify_network_changed(wpa_s);
2080 }
2081
2082
2083 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2084                                             const u8 *addr)
2085 {
2086         struct wpa_ssid *old_ssid;
2087
2088         wpas_connect_work_done(wpa_s);
2089         wpa_clear_keys(wpa_s, addr);
2090         old_ssid = wpa_s->current_ssid;
2091         wpa_supplicant_mark_disassoc(wpa_s);
2092         wpa_sm_set_config(wpa_s->wpa, NULL);
2093         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2094         if (old_ssid != wpa_s->current_ssid)
2095                 wpas_notify_network_changed(wpa_s);
2096         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2097 }
2098
2099
2100 /**
2101  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2102  * @wpa_s: Pointer to wpa_supplicant data
2103  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2104  *
2105  * This function is used to request %wpa_supplicant to deauthenticate from the
2106  * current AP.
2107  */
2108 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2109                                    int reason_code)
2110 {
2111         u8 *addr = NULL;
2112         union wpa_event_data event;
2113         int zero_addr = 0;
2114
2115         wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2116                 " pending_bssid=" MACSTR " reason=%d state=%s",
2117                 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2118                 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2119
2120         if (!is_zero_ether_addr(wpa_s->bssid))
2121                 addr = wpa_s->bssid;
2122         else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2123                  (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2124                   wpa_s->wpa_state == WPA_ASSOCIATING))
2125                 addr = wpa_s->pending_bssid;
2126         else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2127                 /*
2128                  * When using driver-based BSS selection, we may not know the
2129                  * BSSID with which we are currently trying to associate. We
2130                  * need to notify the driver of this disconnection even in such
2131                  * a case, so use the all zeros address here.
2132                  */
2133                 addr = wpa_s->bssid;
2134                 zero_addr = 1;
2135         }
2136
2137 #ifdef CONFIG_TDLS
2138         wpa_tdls_teardown_peers(wpa_s->wpa);
2139 #endif /* CONFIG_TDLS */
2140
2141         if (addr) {
2142                 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2143                 os_memset(&event, 0, sizeof(event));
2144                 event.deauth_info.reason_code = (u16) reason_code;
2145                 event.deauth_info.locally_generated = 1;
2146                 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2147                 if (zero_addr)
2148                         addr = NULL;
2149         }
2150
2151         wpa_supplicant_clear_connection(wpa_s, addr);
2152 }
2153
2154 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2155                                               struct wpa_ssid *ssid)
2156 {
2157         if (!ssid || !ssid->disabled || ssid->disabled == 2)
2158                 return;
2159
2160         ssid->disabled = 0;
2161         wpas_clear_temp_disabled(wpa_s, ssid, 1);
2162         wpas_notify_network_enabled_changed(wpa_s, ssid);
2163
2164         /*
2165          * Try to reassociate since there is no current configuration and a new
2166          * network was made available.
2167          */
2168         if (!wpa_s->current_ssid && !wpa_s->disconnected)
2169                 wpa_s->reassociate = 1;
2170 }
2171
2172
2173 /**
2174  * wpa_supplicant_enable_network - Mark a configured network as enabled
2175  * @wpa_s: wpa_supplicant structure for a network interface
2176  * @ssid: wpa_ssid structure for a configured network or %NULL
2177  *
2178  * Enables the specified network or all networks if no network specified.
2179  */
2180 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2181                                    struct wpa_ssid *ssid)
2182 {
2183         if (ssid == NULL) {
2184                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2185                         wpa_supplicant_enable_one_network(wpa_s, ssid);
2186         } else
2187                 wpa_supplicant_enable_one_network(wpa_s, ssid);
2188
2189         if (wpa_s->reassociate && !wpa_s->disconnected) {
2190                 if (wpa_s->sched_scanning) {
2191                         wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2192                                    "new network to scan filters");
2193                         wpa_supplicant_cancel_sched_scan(wpa_s);
2194                 }
2195
2196                 if (wpa_supplicant_fast_associate(wpa_s) != 1)
2197                         wpa_supplicant_req_scan(wpa_s, 0, 0);
2198         }
2199 }
2200
2201
2202 /**
2203  * wpa_supplicant_disable_network - Mark a configured network as disabled
2204  * @wpa_s: wpa_supplicant structure for a network interface
2205  * @ssid: wpa_ssid structure for a configured network or %NULL
2206  *
2207  * Disables the specified network or all networks if no network specified.
2208  */
2209 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2210                                     struct wpa_ssid *ssid)
2211 {
2212         struct wpa_ssid *other_ssid;
2213         int was_disabled;
2214
2215         if (ssid == NULL) {
2216                 if (wpa_s->sched_scanning)
2217                         wpa_supplicant_cancel_sched_scan(wpa_s);
2218
2219                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2220                      other_ssid = other_ssid->next) {
2221                         was_disabled = other_ssid->disabled;
2222                         if (was_disabled == 2)
2223                                 continue; /* do not change persistent P2P group
2224                                            * data */
2225
2226                         other_ssid->disabled = 1;
2227
2228                         if (was_disabled != other_ssid->disabled)
2229                                 wpas_notify_network_enabled_changed(
2230                                         wpa_s, other_ssid);
2231                 }
2232                 if (wpa_s->current_ssid)
2233                         wpa_supplicant_deauthenticate(
2234                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2235         } else if (ssid->disabled != 2) {
2236                 if (ssid == wpa_s->current_ssid)
2237                         wpa_supplicant_deauthenticate(
2238                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2239
2240                 was_disabled = ssid->disabled;
2241
2242                 ssid->disabled = 1;
2243
2244                 if (was_disabled != ssid->disabled) {
2245                         wpas_notify_network_enabled_changed(wpa_s, ssid);
2246                         if (wpa_s->sched_scanning) {
2247                                 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2248                                            "to remove network from filters");
2249                                 wpa_supplicant_cancel_sched_scan(wpa_s);
2250                                 wpa_supplicant_req_scan(wpa_s, 0, 0);
2251                         }
2252                 }
2253         }
2254 }
2255
2256
2257 /**
2258  * wpa_supplicant_select_network - Attempt association with a network
2259  * @wpa_s: wpa_supplicant structure for a network interface
2260  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2261  */
2262 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2263                                    struct wpa_ssid *ssid)
2264 {
2265
2266         struct wpa_ssid *other_ssid;
2267         int disconnected = 0;
2268
2269         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2270                 wpa_supplicant_deauthenticate(
2271                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2272                 disconnected = 1;
2273         }
2274
2275         if (ssid)
2276                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2277
2278         /*
2279          * Mark all other networks disabled or mark all networks enabled if no
2280          * network specified.
2281          */
2282         for (other_ssid = wpa_s->conf->ssid; other_ssid;
2283              other_ssid = other_ssid->next) {
2284                 int was_disabled = other_ssid->disabled;
2285                 if (was_disabled == 2)
2286                         continue; /* do not change persistent P2P group data */
2287
2288                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
2289                 if (was_disabled && !other_ssid->disabled)
2290                         wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2291
2292                 if (was_disabled != other_ssid->disabled)
2293                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2294         }
2295
2296         if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
2297                 /* We are already associated with the selected network */
2298                 wpa_printf(MSG_DEBUG, "Already associated with the "
2299                            "selected network - do nothing");
2300                 return;
2301         }
2302
2303         if (ssid) {
2304                 wpa_s->current_ssid = ssid;
2305                 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2306         }
2307         wpa_s->connect_without_scan = NULL;
2308         wpa_s->disconnected = 0;
2309         wpa_s->reassociate = 1;
2310
2311         if (wpa_supplicant_fast_associate(wpa_s) != 1)
2312                 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
2313
2314         if (ssid)
2315                 wpas_notify_network_selected(wpa_s, ssid);
2316 }
2317
2318
2319 /**
2320  * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
2321  * @wpa_s: wpa_supplicant structure for a network interface
2322  * @pkcs11_engine_path: PKCS #11 engine path or NULL
2323  * @pkcs11_module_path: PKCS #11 module path or NULL
2324  * Returns: 0 on success; -1 on failure
2325  *
2326  * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
2327  * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
2328  * module path fails the paths will be reset to the default value (NULL).
2329  */
2330 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2331                                            const char *pkcs11_engine_path,
2332                                            const char *pkcs11_module_path)
2333 {
2334         char *pkcs11_engine_path_copy = NULL;
2335         char *pkcs11_module_path_copy = NULL;
2336
2337         if (pkcs11_engine_path != NULL) {
2338                 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
2339                 if (pkcs11_engine_path_copy == NULL)
2340                         return -1;
2341         }
2342         if (pkcs11_module_path != NULL) {
2343                 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
2344                 if (pkcs11_module_path_copy == NULL) {
2345                         os_free(pkcs11_engine_path_copy);
2346                         return -1;
2347                 }
2348         }
2349
2350         os_free(wpa_s->conf->pkcs11_engine_path);
2351         os_free(wpa_s->conf->pkcs11_module_path);
2352         wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2353         wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2354
2355         wpa_sm_set_eapol(wpa_s->wpa, NULL);
2356         eapol_sm_deinit(wpa_s->eapol);
2357         wpa_s->eapol = NULL;
2358         if (wpa_supplicant_init_eapol(wpa_s)) {
2359                 /* Error -> Reset paths to the default value (NULL) once. */
2360                 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
2361                         wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2362                                                                NULL);
2363
2364                 return -1;
2365         }
2366         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2367
2368         return 0;
2369 }
2370
2371
2372 /**
2373  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2374  * @wpa_s: wpa_supplicant structure for a network interface
2375  * @ap_scan: AP scan mode
2376  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2377  *
2378  */
2379 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2380 {
2381
2382         int old_ap_scan;
2383
2384         if (ap_scan < 0 || ap_scan > 2)
2385                 return -1;
2386
2387 #ifdef ANDROID
2388         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2389             wpa_s->wpa_state >= WPA_ASSOCIATING &&
2390             wpa_s->wpa_state < WPA_COMPLETED) {
2391                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
2392                            "associating", wpa_s->conf->ap_scan, ap_scan);
2393                 return 0;
2394         }
2395 #endif /* ANDROID */
2396
2397         old_ap_scan = wpa_s->conf->ap_scan;
2398         wpa_s->conf->ap_scan = ap_scan;
2399
2400         if (old_ap_scan != wpa_s->conf->ap_scan)
2401                 wpas_notify_ap_scan_changed(wpa_s);
2402
2403         return 0;
2404 }
2405
2406
2407 /**
2408  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
2409  * @wpa_s: wpa_supplicant structure for a network interface
2410  * @expire_age: Expiration age in seconds
2411  * Returns: 0 if succeed or -1 if expire_age has an invalid value
2412  *
2413  */
2414 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
2415                                           unsigned int bss_expire_age)
2416 {
2417         if (bss_expire_age < 10) {
2418                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
2419                         bss_expire_age);
2420                 return -1;
2421         }
2422         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
2423                 bss_expire_age);
2424         wpa_s->conf->bss_expiration_age = bss_expire_age;
2425
2426         return 0;
2427 }
2428
2429
2430 /**
2431  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
2432  * @wpa_s: wpa_supplicant structure for a network interface
2433  * @expire_count: number of scans after which an unseen BSS is reclaimed
2434  * Returns: 0 if succeed or -1 if expire_count has an invalid value
2435  *
2436  */
2437 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
2438                                             unsigned int bss_expire_count)
2439 {
2440         if (bss_expire_count < 1) {
2441                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
2442                         bss_expire_count);
2443                 return -1;
2444         }
2445         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
2446                 bss_expire_count);
2447         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
2448
2449         return 0;
2450 }
2451
2452
2453 /**
2454  * wpa_supplicant_set_scan_interval - Set scan interval
2455  * @wpa_s: wpa_supplicant structure for a network interface
2456  * @scan_interval: scan interval in seconds
2457  * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2458  *
2459  */
2460 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
2461                                      int scan_interval)
2462 {
2463         if (scan_interval < 0) {
2464                 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
2465                         scan_interval);
2466                 return -1;
2467         }
2468         wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
2469                 scan_interval);
2470         wpa_supplicant_update_scan_int(wpa_s, scan_interval);
2471
2472         return 0;
2473 }
2474
2475
2476 /**
2477  * wpa_supplicant_set_debug_params - Set global debug params
2478  * @global: wpa_global structure
2479  * @debug_level: debug level
2480  * @debug_timestamp: determines if show timestamp in debug data
2481  * @debug_show_keys: determines if show keys in debug data
2482  * Returns: 0 if succeed or -1 if debug_level has wrong value
2483  */
2484 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
2485                                     int debug_timestamp, int debug_show_keys)
2486 {
2487
2488         int old_level, old_timestamp, old_show_keys;
2489
2490         /* check for allowed debuglevels */
2491         if (debug_level != MSG_EXCESSIVE &&
2492             debug_level != MSG_MSGDUMP &&
2493             debug_level != MSG_DEBUG &&
2494             debug_level != MSG_INFO &&
2495             debug_level != MSG_WARNING &&
2496             debug_level != MSG_ERROR)
2497                 return -1;
2498
2499         old_level = wpa_debug_level;
2500         old_timestamp = wpa_debug_timestamp;
2501         old_show_keys = wpa_debug_show_keys;
2502
2503         wpa_debug_level = debug_level;
2504         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2505         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2506
2507         if (wpa_debug_level != old_level)
2508                 wpas_notify_debug_level_changed(global);
2509         if (wpa_debug_timestamp != old_timestamp)
2510                 wpas_notify_debug_timestamp_changed(global);
2511         if (wpa_debug_show_keys != old_show_keys)
2512                 wpas_notify_debug_show_keys_changed(global);
2513
2514         return 0;
2515 }
2516
2517
2518 /**
2519  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2520  * @wpa_s: Pointer to wpa_supplicant data
2521  * Returns: A pointer to the current network structure or %NULL on failure
2522  */
2523 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2524 {
2525         struct wpa_ssid *entry;
2526         u8 ssid[MAX_SSID_LEN];
2527         int res;
2528         size_t ssid_len;
2529         u8 bssid[ETH_ALEN];
2530         int wired;
2531
2532         res = wpa_drv_get_ssid(wpa_s, ssid);
2533         if (res < 0) {
2534                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2535                         "driver");
2536                 return NULL;
2537         }
2538         ssid_len = res;
2539
2540         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2541                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2542                         "driver");
2543                 return NULL;
2544         }
2545
2546         wired = wpa_s->conf->ap_scan == 0 &&
2547                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2548
2549         entry = wpa_s->conf->ssid;
2550         while (entry) {
2551                 if (!wpas_network_disabled(wpa_s, entry) &&
2552                     ((ssid_len == entry->ssid_len &&
2553                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2554                     (!entry->bssid_set ||
2555                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2556                         return entry;
2557 #ifdef CONFIG_WPS
2558                 if (!wpas_network_disabled(wpa_s, entry) &&
2559                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2560                     (entry->ssid == NULL || entry->ssid_len == 0) &&
2561                     (!entry->bssid_set ||
2562                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2563                         return entry;
2564 #endif /* CONFIG_WPS */
2565
2566                 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2567                     entry->ssid_len == 0 &&
2568                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2569                         return entry;
2570
2571                 entry = entry->next;
2572         }
2573
2574         return NULL;
2575 }
2576
2577
2578 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2579 {
2580         struct wpa_global *global = wpa_s->global;
2581
2582         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2583                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2584                 if (global->drv_priv[i] == NULL) {
2585                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2586                                    "'%s'", wpa_drivers[i]->name);
2587                         return -1;
2588                 }
2589         }
2590
2591         wpa_s->driver = wpa_drivers[i];
2592         wpa_s->global_drv_priv = global->drv_priv[i];
2593
2594         return 0;
2595 }
2596
2597
2598 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2599                                      const char *name)
2600 {
2601         int i;
2602         size_t len;
2603         const char *pos, *driver = name;
2604
2605         if (wpa_s == NULL)
2606                 return -1;
2607
2608         if (wpa_drivers[0] == NULL) {
2609                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2610                         "wpa_supplicant");
2611                 return -1;
2612         }
2613
2614         if (name == NULL) {
2615                 /* default to first driver in the list */
2616                 return select_driver(wpa_s, 0);
2617         }
2618
2619         do {
2620                 pos = os_strchr(driver, ',');
2621                 if (pos)
2622                         len = pos - driver;
2623                 else
2624                         len = os_strlen(driver);
2625
2626                 for (i = 0; wpa_drivers[i]; i++) {
2627                         if (os_strlen(wpa_drivers[i]->name) == len &&
2628                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
2629                             0) {
2630                                 /* First driver that succeeds wins */
2631                                 if (select_driver(wpa_s, i) == 0)
2632                                         return 0;
2633                         }
2634                 }
2635
2636                 driver = pos + 1;
2637         } while (pos);
2638
2639         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2640         return -1;
2641 }
2642
2643
2644 /**
2645  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2646  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2647  *      with struct wpa_driver_ops::init()
2648  * @src_addr: Source address of the EAPOL frame
2649  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2650  * @len: Length of the EAPOL data
2651  *
2652  * This function is called for each received EAPOL frame. Most driver
2653  * interfaces rely on more generic OS mechanism for receiving frames through
2654  * l2_packet, but if such a mechanism is not available, the driver wrapper may
2655  * take care of received EAPOL frames and deliver them to the core supplicant
2656  * code by calling this function.
2657  */
2658 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
2659                              const u8 *buf, size_t len)
2660 {
2661         struct wpa_supplicant *wpa_s = ctx;
2662
2663         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2664         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
2665
2666 #ifdef CONFIG_PEERKEY
2667         if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
2668             wpa_s->current_ssid->peerkey &&
2669             !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2670             wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
2671                 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
2672                 return;
2673         }
2674 #endif /* CONFIG_PEERKEY */
2675
2676         if (wpa_s->wpa_state < WPA_ASSOCIATED ||
2677             (wpa_s->last_eapol_matches_bssid &&
2678 #ifdef CONFIG_AP
2679              !wpa_s->ap_iface &&
2680 #endif /* CONFIG_AP */
2681              os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
2682                 /*
2683                  * There is possible race condition between receiving the
2684                  * association event and the EAPOL frame since they are coming
2685                  * through different paths from the driver. In order to avoid
2686                  * issues in trying to process the EAPOL frame before receiving
2687                  * association information, lets queue it for processing until
2688                  * the association event is received. This may also be needed in
2689                  * driver-based roaming case, so also use src_addr != BSSID as a
2690                  * trigger if we have previously confirmed that the
2691                  * Authenticator uses BSSID as the src_addr (which is not the
2692                  * case with wired IEEE 802.1X).
2693                  */
2694                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2695                         "of received EAPOL frame (state=%s bssid=" MACSTR ")",
2696                         wpa_supplicant_state_txt(wpa_s->wpa_state),
2697                         MAC2STR(wpa_s->bssid));
2698                 wpabuf_free(wpa_s->pending_eapol_rx);
2699                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2700                 if (wpa_s->pending_eapol_rx) {
2701                         os_get_reltime(&wpa_s->pending_eapol_rx_time);
2702                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2703                                   ETH_ALEN);
2704                 }
2705                 return;
2706         }
2707
2708         wpa_s->last_eapol_matches_bssid =
2709                 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
2710
2711 #ifdef CONFIG_AP
2712         if (wpa_s->ap_iface) {
2713                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2714                 return;
2715         }
2716 #endif /* CONFIG_AP */
2717
2718         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2719                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2720                         "no key management is configured");
2721                 return;
2722         }
2723
2724         if (wpa_s->eapol_received == 0 &&
2725             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2726              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2727              wpa_s->wpa_state != WPA_COMPLETED) &&
2728             (wpa_s->current_ssid == NULL ||
2729              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2730                 /* Timeout for completing IEEE 802.1X and WPA authentication */
2731                 wpa_supplicant_req_auth_timeout(
2732                         wpa_s,
2733                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2734                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2735                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2736                         70 : 10, 0);
2737         }
2738         wpa_s->eapol_received++;
2739
2740         if (wpa_s->countermeasures) {
2741                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2742                         "EAPOL packet");
2743                 return;
2744         }
2745
2746 #ifdef CONFIG_IBSS_RSN
2747         if (wpa_s->current_ssid &&
2748             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2749                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2750                 return;
2751         }
2752 #endif /* CONFIG_IBSS_RSN */
2753
2754         /* Source address of the incoming EAPOL frame could be compared to the
2755          * current BSSID. However, it is possible that a centralized
2756          * Authenticator could be using another MAC address than the BSSID of
2757          * an AP, so just allow any address to be used for now. The replies are
2758          * still sent to the current BSSID (if available), though. */
2759
2760         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2761         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2762             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2763                 return;
2764         wpa_drv_poll(wpa_s);
2765         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2766                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2767         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2768                 /*
2769                  * Set portValid = TRUE here since we are going to skip 4-way
2770                  * handshake processing which would normally set portValid. We
2771                  * need this to allow the EAPOL state machines to be completed
2772                  * without going through EAPOL-Key handshake.
2773                  */
2774                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2775         }
2776 }
2777
2778
2779 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2780 {
2781         if (wpa_s->driver->send_eapol) {
2782                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2783                 if (addr)
2784                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2785         } else if ((!wpa_s->p2p_mgmt ||
2786                     !(wpa_s->drv_flags &
2787                       WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
2788                    !(wpa_s->drv_flags &
2789                      WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
2790                 l2_packet_deinit(wpa_s->l2);
2791                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2792                                            wpa_drv_get_mac_addr(wpa_s),
2793                                            ETH_P_EAPOL,
2794                                            wpa_supplicant_rx_eapol, wpa_s, 0);
2795                 if (wpa_s->l2 == NULL)
2796                         return -1;
2797         } else {
2798                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2799                 if (addr)
2800                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2801         }
2802
2803         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2804                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2805                 return -1;
2806         }
2807
2808         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2809
2810         return 0;
2811 }
2812
2813
2814 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
2815                                            const u8 *buf, size_t len)
2816 {
2817         struct wpa_supplicant *wpa_s = ctx;
2818         const struct l2_ethhdr *eth;
2819
2820         if (len < sizeof(*eth))
2821                 return;
2822         eth = (const struct l2_ethhdr *) buf;
2823
2824         if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2825             !(eth->h_dest[0] & 0x01)) {
2826                 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2827                         " (bridge - not for this interface - ignore)",
2828                         MAC2STR(src_addr), MAC2STR(eth->h_dest));
2829                 return;
2830         }
2831
2832         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2833                 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
2834         wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2835                                 len - sizeof(*eth));
2836 }
2837
2838
2839 /**
2840  * wpa_supplicant_driver_init - Initialize driver interface parameters
2841  * @wpa_s: Pointer to wpa_supplicant data
2842  * Returns: 0 on success, -1 on failure
2843  *
2844  * This function is called to initialize driver interface parameters.
2845  * wpa_drv_init() must have been called before this function to initialize the
2846  * driver interface.
2847  */
2848 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2849 {
2850         static int interface_count = 0;
2851
2852         if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2853                 return -1;
2854
2855         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2856                 MAC2STR(wpa_s->own_addr));
2857         os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
2858         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2859
2860         if (wpa_s->bridge_ifname[0]) {
2861                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2862                         "interface '%s'", wpa_s->bridge_ifname);
2863                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2864                                               wpa_s->own_addr,
2865                                               ETH_P_EAPOL,
2866                                               wpa_supplicant_rx_eapol_bridge,
2867                                               wpa_s, 1);
2868                 if (wpa_s->l2_br == NULL) {
2869                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2870                                 "connection for the bridge interface '%s'",
2871                                 wpa_s->bridge_ifname);
2872                         return -1;
2873                 }
2874         }
2875
2876         wpa_clear_keys(wpa_s, NULL);
2877
2878         /* Make sure that TKIP countermeasures are not left enabled (could
2879          * happen if wpa_supplicant is killed during countermeasures. */
2880         wpa_drv_set_countermeasures(wpa_s, 0);
2881
2882         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2883         wpa_drv_flush_pmkid(wpa_s);
2884
2885         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2886         wpa_s->prev_scan_wildcard = 0;
2887
2888         if (wpa_supplicant_enabled_networks(wpa_s)) {
2889                 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
2890                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2891                         interface_count = 0;
2892                 }
2893                 if (!wpa_s->p2p_mgmt &&
2894                     wpa_supplicant_delayed_sched_scan(wpa_s,
2895                                                       interface_count % 3,
2896                                                       100000))
2897                         wpa_supplicant_req_scan(wpa_s, interface_count % 3,
2898                                                 100000);
2899                 interface_count++;
2900         } else
2901                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2902
2903         return 0;
2904 }
2905
2906
2907 static int wpa_supplicant_daemon(const char *pid_file)
2908 {
2909         wpa_printf(MSG_DEBUG, "Daemonize..");
2910         return os_daemonize(pid_file);
2911 }
2912
2913
2914 static struct wpa_supplicant * wpa_supplicant_alloc(void)
2915 {
2916         struct wpa_supplicant *wpa_s;
2917
2918         wpa_s = os_zalloc(sizeof(*wpa_s));
2919         if (wpa_s == NULL)
2920                 return NULL;
2921         wpa_s->scan_req = INITIAL_SCAN_REQ;
2922         wpa_s->scan_interval = 5;
2923         wpa_s->new_connection = 1;
2924         wpa_s->parent = wpa_s;
2925         wpa_s->sched_scanning = 0;
2926
2927         return wpa_s;
2928 }
2929
2930
2931 #ifdef CONFIG_HT_OVERRIDES
2932
2933 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2934                              struct ieee80211_ht_capabilities *htcaps,
2935                              struct ieee80211_ht_capabilities *htcaps_mask,
2936                              const char *ht_mcs)
2937 {
2938         /* parse ht_mcs into hex array */
2939         int i;
2940         const char *tmp = ht_mcs;
2941         char *end = NULL;
2942
2943         /* If ht_mcs is null, do not set anything */
2944         if (!ht_mcs)
2945                 return 0;
2946
2947         /* This is what we are setting in the kernel */
2948         os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
2949
2950         wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2951
2952         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2953                 errno = 0;
2954                 long v = strtol(tmp, &end, 16);
2955                 if (errno == 0) {
2956                         wpa_msg(wpa_s, MSG_DEBUG,
2957                                 "htcap value[%i]: %ld end: %p  tmp: %p",
2958                                 i, v, end, tmp);
2959                         if (end == tmp)
2960                                 break;
2961
2962                         htcaps->supported_mcs_set[i] = v;
2963                         tmp = end;
2964                 } else {
2965                         wpa_msg(wpa_s, MSG_ERROR,
2966                                 "Failed to parse ht-mcs: %s, error: %s\n",
2967                                 ht_mcs, strerror(errno));
2968                         return -1;
2969                 }
2970         }
2971
2972         /*
2973          * If we were able to parse any values, then set mask for the MCS set.
2974          */
2975         if (i) {
2976                 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
2977                           IEEE80211_HT_MCS_MASK_LEN - 1);
2978                 /* skip the 3 reserved bits */
2979                 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
2980                         0x1f;
2981         }
2982
2983         return 0;
2984 }
2985
2986
2987 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2988                                  struct ieee80211_ht_capabilities *htcaps,
2989                                  struct ieee80211_ht_capabilities *htcaps_mask,
2990                                  int disabled)
2991 {
2992         le16 msk;
2993
2994         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2995
2996         if (disabled == -1)
2997                 return 0;
2998
2999         msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3000         htcaps_mask->ht_capabilities_info |= msk;
3001         if (disabled)
3002                 htcaps->ht_capabilities_info &= msk;
3003         else
3004                 htcaps->ht_capabilities_info |= msk;
3005
3006         return 0;
3007 }
3008
3009
3010 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3011                                 struct ieee80211_ht_capabilities *htcaps,
3012                                 struct ieee80211_ht_capabilities *htcaps_mask,
3013                                 int factor)
3014 {
3015         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3016
3017         if (factor == -1)
3018                 return 0;
3019
3020         if (factor < 0 || factor > 3) {
3021                 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3022                         "Must be 0-3 or -1", factor);
3023                 return -EINVAL;
3024         }
3025
3026         htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3027         htcaps->a_mpdu_params &= ~0x3;
3028         htcaps->a_mpdu_params |= factor & 0x3;
3029
3030         return 0;
3031 }
3032
3033
3034 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3035                                  struct ieee80211_ht_capabilities *htcaps,
3036                                  struct ieee80211_ht_capabilities *htcaps_mask,
3037                                  int density)
3038 {
3039         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3040
3041         if (density == -1)
3042                 return 0;
3043
3044         if (density < 0 || density > 7) {
3045                 wpa_msg(wpa_s, MSG_ERROR,
3046                         "ampdu_density: %d out of range. Must be 0-7 or -1.",
3047                         density);
3048                 return -EINVAL;
3049         }
3050
3051         htcaps_mask->a_mpdu_params |= 0x1C;
3052         htcaps->a_mpdu_params &= ~(0x1C);
3053         htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3054
3055         return 0;
3056 }
3057
3058
3059 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3060                                 struct ieee80211_ht_capabilities *htcaps,
3061                                 struct ieee80211_ht_capabilities *htcaps_mask,
3062                                 int disabled)
3063 {
3064         /* Masking these out disables HT40 */
3065         le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3066                                 HT_CAP_INFO_SHORT_GI40MHZ);
3067
3068         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3069
3070         if (disabled)
3071                 htcaps->ht_capabilities_info &= ~msk;
3072         else
3073                 htcaps->ht_capabilities_info |= msk;
3074
3075         htcaps_mask->ht_capabilities_info |= msk;
3076
3077         return 0;
3078 }
3079
3080
3081 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3082                                struct ieee80211_ht_capabilities *htcaps,
3083                                struct ieee80211_ht_capabilities *htcaps_mask,
3084                                int disabled)
3085 {
3086         /* Masking these out disables SGI */
3087         le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3088                                 HT_CAP_INFO_SHORT_GI40MHZ);
3089
3090         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3091
3092         if (disabled)
3093                 htcaps->ht_capabilities_info &= ~msk;
3094         else
3095                 htcaps->ht_capabilities_info |= msk;
3096
3097         htcaps_mask->ht_capabilities_info |= msk;
3098
3099         return 0;
3100 }
3101
3102
3103 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3104                                struct ieee80211_ht_capabilities *htcaps,
3105                                struct ieee80211_ht_capabilities *htcaps_mask,
3106                                int disabled)
3107 {
3108         /* Masking these out disables LDPC */
3109         le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
3110
3111         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3112
3113         if (disabled)
3114                 htcaps->ht_capabilities_info &= ~msk;
3115         else
3116                 htcaps->ht_capabilities_info |= msk;
3117
3118         htcaps_mask->ht_capabilities_info |= msk;
3119
3120         return 0;
3121 }
3122
3123
3124 void wpa_supplicant_apply_ht_overrides(
3125         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3126         struct wpa_driver_associate_params *params)
3127 {
3128         struct ieee80211_ht_capabilities *htcaps;
3129         struct ieee80211_ht_capabilities *htcaps_mask;
3130
3131         if (!ssid)
3132                 return;
3133
3134         params->disable_ht = ssid->disable_ht;
3135         if (!params->htcaps || !params->htcaps_mask)
3136                 return;
3137
3138         htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3139         htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3140         wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3141         wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3142                               ssid->disable_max_amsdu);
3143         wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3144         wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3145         wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3146         wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3147         wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3148
3149         if (ssid->ht40_intolerant) {
3150                 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
3151                 htcaps->ht_capabilities_info |= bit;
3152                 htcaps_mask->ht_capabilities_info |= bit;
3153         }
3154 }
3155
3156 #endif /* CONFIG_HT_OVERRIDES */
3157
3158
3159 #ifdef CONFIG_VHT_OVERRIDES
3160 void wpa_supplicant_apply_vht_overrides(
3161         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3162         struct wpa_driver_associate_params *params)
3163 {
3164         struct ieee80211_vht_capabilities *vhtcaps;
3165         struct ieee80211_vht_capabilities *vhtcaps_mask;
3166 #ifdef CONFIG_HT_OVERRIDES
3167         int max_ampdu;
3168         const u32 max_ampdu_mask = VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX;
3169 #endif /* CONFIG_HT_OVERRIDES */
3170
3171         if (!ssid)
3172                 return;
3173
3174         params->disable_vht = ssid->disable_vht;
3175
3176         vhtcaps = (void *) params->vhtcaps;
3177         vhtcaps_mask = (void *) params->vhtcaps_mask;
3178
3179         if (!vhtcaps || !vhtcaps_mask)
3180                 return;
3181
3182         vhtcaps->vht_capabilities_info = ssid->vht_capa;
3183         vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
3184
3185 #ifdef CONFIG_HT_OVERRIDES
3186         /* if max ampdu is <= 3, we have to make the HT cap the same */
3187         if (ssid->vht_capa_mask & max_ampdu_mask) {
3188                 max_ampdu = (ssid->vht_capa & max_ampdu_mask) >>
3189                         find_first_bit(max_ampdu_mask);
3190
3191                 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3192                 wpa_set_ampdu_factor(wpa_s,
3193                                      (void *) params->htcaps,
3194                                      (void *) params->htcaps_mask,
3195                                      max_ampdu);
3196         }
3197 #endif /* CONFIG_HT_OVERRIDES */
3198
3199 #define OVERRIDE_MCS(i)                                                 \
3200         if (ssid->vht_tx_mcs_nss_ ##i >= 0) {                           \
3201                 vhtcaps_mask->vht_supported_mcs_set.tx_map |=           \
3202                         3 << 2 * (i - 1);                               \
3203                 vhtcaps->vht_supported_mcs_set.tx_map |=                \
3204                         ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1);       \
3205         }                                                               \
3206         if (ssid->vht_rx_mcs_nss_ ##i >= 0) {                           \
3207                 vhtcaps_mask->vht_supported_mcs_set.rx_map |=           \
3208                         3 << 2 * (i - 1);                               \
3209                 vhtcaps->vht_supported_mcs_set.rx_map |=                \
3210                         ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1);       \
3211         }
3212
3213         OVERRIDE_MCS(1);
3214         OVERRIDE_MCS(2);
3215         OVERRIDE_MCS(3);
3216         OVERRIDE_MCS(4);
3217         OVERRIDE_MCS(5);
3218         OVERRIDE_MCS(6);
3219         OVERRIDE_MCS(7);
3220         OVERRIDE_MCS(8);
3221 }
3222 #endif /* CONFIG_VHT_OVERRIDES */
3223
3224
3225 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3226 {
3227 #ifdef PCSC_FUNCS
3228         size_t len;
3229
3230         if (!wpa_s->conf->pcsc_reader)
3231                 return 0;
3232
3233         wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3234         if (!wpa_s->scard)
3235                 return 1;
3236
3237         if (wpa_s->conf->pcsc_pin &&
3238             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3239                 scard_deinit(wpa_s->scard);
3240                 wpa_s->scard = NULL;
3241                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3242                 return -1;
3243         }
3244
3245         len = sizeof(wpa_s->imsi) - 1;
3246         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3247                 scard_deinit(wpa_s->scard);
3248                 wpa_s->scard = NULL;
3249                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3250                 return -1;
3251         }
3252         wpa_s->imsi[len] = '\0';
3253
3254         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3255
3256         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3257                    wpa_s->imsi, wpa_s->mnc_len);
3258
3259         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3260         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3261 #endif /* PCSC_FUNCS */
3262
3263         return 0;
3264 }
3265
3266
3267 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3268 {
3269         char *val, *pos;
3270
3271         ext_password_deinit(wpa_s->ext_pw);
3272         wpa_s->ext_pw = NULL;
3273         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3274
3275         if (!wpa_s->conf->ext_password_backend)
3276                 return 0;
3277
3278         val = os_strdup(wpa_s->conf->ext_password_backend);
3279         if (val == NULL)
3280                 return -1;
3281         pos = os_strchr(val, ':');
3282         if (pos)
3283                 *pos++ = '\0';
3284
3285         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
3286
3287         wpa_s->ext_pw = ext_password_init(val, pos);
3288         os_free(val);
3289         if (wpa_s->ext_pw == NULL) {
3290                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
3291                 return -1;
3292         }
3293         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3294
3295         return 0;
3296 }
3297
3298
3299 static int wpas_check_wowlan_trigger(const char *start, const char *trigger,
3300                                      int capa_trigger, u8 *param_trigger)
3301 {
3302         if (os_strcmp(start, trigger) != 0)
3303                 return 0;
3304         if (!capa_trigger)
3305                 return 0;
3306
3307         *param_trigger = 1;
3308         return 1;
3309 }
3310
3311
3312 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
3313                                     const struct wpa_driver_capa *capa)
3314 {
3315         struct wowlan_triggers triggers;
3316         char *start, *end, *buf;
3317         int last, ret;
3318
3319         if (!wpa_s->conf->wowlan_triggers)
3320                 return 0;
3321
3322         buf = os_strdup(wpa_s->conf->wowlan_triggers);
3323         if (buf == NULL)
3324                 return -1;
3325
3326         os_memset(&triggers, 0, sizeof(triggers));
3327
3328 #define CHECK_TRIGGER(trigger) \
3329         wpas_check_wowlan_trigger(start, #trigger,                      \
3330                                   capa->wowlan_triggers.trigger,        \
3331                                   &triggers.trigger)
3332
3333         start = buf;
3334         while (*start != '\0') {
3335                 while (isblank(*start))
3336                         start++;
3337                 if (*start == '\0')
3338                         break;
3339                 end = start;
3340                 while (!isblank(*end) && *end != '\0')
3341                         end++;
3342                 last = *end == '\0';
3343                 *end = '\0';
3344
3345                 if (!CHECK_TRIGGER(any) &&
3346                     !CHECK_TRIGGER(disconnect) &&
3347                     !CHECK_TRIGGER(magic_pkt) &&
3348                     !CHECK_TRIGGER(gtk_rekey_failure) &&
3349                     !CHECK_TRIGGER(eap_identity_req) &&
3350                     !CHECK_TRIGGER(four_way_handshake) &&
3351                     !CHECK_TRIGGER(rfkill_release)) {
3352                         wpa_printf(MSG_DEBUG,
3353                                    "Unknown/unsupported wowlan trigger '%s'",
3354                                    start);
3355                         ret = -1;
3356                         goto out;
3357                 }
3358
3359                 if (last)
3360                         break;
3361                 start = end + 1;
3362         }
3363 #undef CHECK_TRIGGER
3364
3365         ret = wpa_drv_wowlan(wpa_s, &triggers);
3366 out:
3367         os_free(buf);
3368         return ret;
3369 }
3370
3371
3372 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
3373                                               const char *rn)
3374 {
3375         struct wpa_supplicant *iface = wpa_s->global->ifaces;
3376         struct wpa_radio *radio;
3377
3378         while (rn && iface) {
3379                 radio = iface->radio;
3380                 if (radio && os_strcmp(rn, radio->name) == 0) {
3381                         wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
3382                                    wpa_s->ifname, rn);
3383                         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3384                         return radio;
3385                 }
3386
3387                 iface = iface->next;
3388         }
3389
3390         wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
3391                    wpa_s->ifname, rn ? rn : "N/A");
3392         radio = os_zalloc(sizeof(*radio));
3393         if (radio == NULL)
3394                 return NULL;
3395
3396         if (rn)
3397                 os_strlcpy(radio->name, rn, sizeof(radio->name));
3398         dl_list_init(&radio->ifaces);
3399         dl_list_init(&radio->work);
3400         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3401
3402         return radio;
3403 }
3404
3405
3406 static void radio_work_free(struct wpa_radio_work *work)
3407 {
3408         if (work->wpa_s->scan_work == work) {
3409                 /* This should not really happen. */
3410                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3411                         work->type, work, work->started);
3412                 work->wpa_s->scan_work = NULL;
3413         }
3414
3415 #ifdef CONFIG_P2P
3416         if (work->wpa_s->p2p_scan_work == work) {
3417                 /* This should not really happen. */
3418                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3419                         work->type, work, work->started);
3420                 work->wpa_s->p2p_scan_work = NULL;
3421         }
3422 #endif /* CONFIG_P2P */
3423
3424         dl_list_del(&work->list);
3425         os_free(work);
3426 }
3427
3428
3429 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
3430 {
3431         struct wpa_radio *radio = eloop_ctx;
3432         struct wpa_radio_work *work;
3433         struct os_reltime now, diff;
3434         struct wpa_supplicant *wpa_s;
3435
3436         work = dl_list_first(&radio->work, struct wpa_radio_work, list);
3437         if (work == NULL)
3438                 return;
3439
3440         if (work->started)
3441                 return; /* already started and still in progress */
3442
3443         wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
3444                               radio_list);
3445         if (wpa_s && wpa_s->external_scan_running) {
3446                 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
3447                 return;
3448         }
3449
3450         os_get_reltime(&now);
3451         os_reltime_sub(&now, &work->time, &diff);
3452         wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3453                 work->type, work, diff.sec, diff.usec);
3454         work->started = 1;
3455         work->time = now;
3456         work->cb(work, 0);
3457 }
3458
3459
3460 /*
3461  * This function removes both started and pending radio works running on
3462  * the provided interface's radio.
3463  * Prior to the removal of the radio work, its callback (cb) is called with
3464  * deinit set to be 1. Each work's callback is responsible for clearing its
3465  * internal data and restoring to a correct state.
3466  * @wpa_s: wpa_supplicant data
3467  * @type: type of works to be removed
3468  * @remove_all: 1 to remove all the works on this radio, 0 to remove only
3469  * this interface's works.
3470  */
3471 void radio_remove_works(struct wpa_supplicant *wpa_s,
3472                         const char *type, int remove_all)
3473 {
3474         struct wpa_radio_work *work, *tmp;
3475         struct wpa_radio *radio = wpa_s->radio;
3476
3477         dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
3478                               list) {
3479                 if (type && os_strcmp(type, work->type) != 0)
3480                         continue;
3481
3482                 /* skip other ifaces' works */
3483                 if (!remove_all && work->wpa_s != wpa_s)
3484                         continue;
3485
3486                 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
3487                         work->type, work, work->started ? " (started)" : "");
3488                 work->cb(work, 1);
3489                 radio_work_free(work);
3490         }
3491
3492         /* in case we removed the started work */
3493         radio_work_check_next(wpa_s);
3494 }
3495
3496
3497 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
3498 {
3499         struct wpa_radio *radio = wpa_s->radio;
3500
3501         if (!radio)
3502                 return;
3503
3504         wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
3505                    wpa_s->ifname, radio->name);
3506         dl_list_del(&wpa_s->radio_list);
3507         radio_remove_works(wpa_s, NULL, 0);
3508         wpa_s->radio = NULL;
3509         if (!dl_list_empty(&radio->ifaces))
3510                 return; /* Interfaces remain for this radio */
3511
3512         wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
3513         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3514         os_free(radio);
3515 }
3516
3517
3518 void radio_work_check_next(struct wpa_supplicant *wpa_s)
3519 {
3520         struct wpa_radio *radio = wpa_s->radio;
3521
3522         if (dl_list_empty(&radio->work))
3523                 return;
3524         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3525         eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
3526 }
3527
3528
3529 /**
3530  * radio_add_work - Add a radio work item
3531  * @wpa_s: Pointer to wpa_supplicant data
3532  * @freq: Frequency of the offchannel operation in MHz or 0
3533  * @type: Unique identifier for each type of work
3534  * @next: Force as the next work to be executed
3535  * @cb: Callback function for indicating when radio is available
3536  * @ctx: Context pointer for the work (work->ctx in cb())
3537  * Returns: 0 on success, -1 on failure
3538  *
3539  * This function is used to request time for an operation that requires
3540  * exclusive radio control. Once the radio is available, the registered callback
3541  * function will be called. radio_work_done() must be called once the exclusive
3542  * radio operation has been completed, so that the radio is freed for other
3543  * operations. The special case of deinit=1 is used to free the context data
3544  * during interface removal. That does not allow the callback function to start
3545  * the radio operation, i.e., it must free any resources allocated for the radio
3546  * work and return.
3547  *
3548  * The @freq parameter can be used to indicate a single channel on which the
3549  * offchannel operation will occur. This may allow multiple radio work
3550  * operations to be performed in parallel if they apply for the same channel.
3551  * Setting this to 0 indicates that the work item may use multiple channels or
3552  * requires exclusive control of the radio.
3553  */
3554 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
3555                    const char *type, int next,
3556                    void (*cb)(struct wpa_radio_work *work, int deinit),
3557                    void *ctx)
3558 {
3559         struct wpa_radio_work *work;
3560         int was_empty;
3561
3562         work = os_zalloc(sizeof(*work));
3563         if (work == NULL)
3564                 return -1;
3565         wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
3566         os_get_reltime(&work->time);
3567         work->freq = freq;
3568         work->type = type;
3569         work->wpa_s = wpa_s;
3570         work->cb = cb;
3571         work->ctx = ctx;
3572
3573         was_empty = dl_list_empty(&wpa_s->radio->work);
3574         if (next)
3575                 dl_list_add(&wpa_s->radio->work, &work->list);
3576         else
3577                 dl_list_add_tail(&wpa_s->radio->work, &work->list);
3578         if (was_empty) {
3579                 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
3580                 radio_work_check_next(wpa_s);
3581         }
3582
3583         return 0;
3584 }
3585
3586
3587 /**
3588  * radio_work_done - Indicate that a radio work item has been completed
3589  * @work: Completed work
3590  *
3591  * This function is called once the callback function registered with
3592  * radio_add_work() has completed its work.
3593  */
3594 void radio_work_done(struct wpa_radio_work *work)
3595 {
3596         struct wpa_supplicant *wpa_s = work->wpa_s;
3597         struct os_reltime now, diff;
3598         unsigned int started = work->started;
3599
3600         os_get_reltime(&now);
3601         os_reltime_sub(&now, &work->time, &diff);
3602         wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3603                 work->type, work, started ? "done" : "canceled",
3604                 diff.sec, diff.usec);
3605         radio_work_free(work);
3606         if (started)
3607                 radio_work_check_next(wpa_s);
3608 }
3609
3610
3611 int radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
3612 {
3613         struct wpa_radio_work *work;
3614         struct wpa_radio *radio = wpa_s->radio;
3615
3616         dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
3617                 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
3618                         return 1;
3619         }
3620
3621         return 0;
3622 }
3623
3624
3625 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
3626                             struct wpa_interface *iface)
3627 {
3628         const char *ifname, *driver, *rn;
3629
3630         driver = iface->driver;
3631 next_driver:
3632         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
3633                 return -1;
3634
3635         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
3636         if (wpa_s->drv_priv == NULL) {
3637                 const char *pos;
3638                 pos = driver ? os_strchr(driver, ',') : NULL;
3639                 if (pos) {
3640                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
3641                                 "driver interface - try next driver wrapper");
3642                         driver = pos + 1;
3643                         goto next_driver;
3644                 }
3645                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
3646                         "interface");
3647                 return -1;
3648         }
3649         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
3650                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
3651                         "driver_param '%s'", wpa_s->conf->driver_param);
3652                 return -1;
3653         }
3654
3655         ifname = wpa_drv_get_ifname(wpa_s);
3656         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
3657                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
3658                         "interface name with '%s'", ifname);
3659                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
3660         }
3661
3662         rn = wpa_driver_get_radio_name(wpa_s);
3663         if (rn && rn[0] == '\0')
3664                 rn = NULL;
3665
3666         wpa_s->radio = radio_add_interface(wpa_s, rn);
3667         if (wpa_s->radio == NULL)
3668                 return -1;
3669
3670         return 0;
3671 }
3672
3673
3674 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
3675                                      struct wpa_interface *iface)
3676 {
3677         struct wpa_driver_capa capa;
3678         int capa_res;
3679
3680         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
3681                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
3682                    iface->confname ? iface->confname : "N/A",
3683                    iface->driver ? iface->driver : "default",
3684                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
3685                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
3686
3687         if (iface->confname) {
3688 #ifdef CONFIG_BACKEND_FILE
3689                 wpa_s->confname = os_rel2abs_path(iface->confname);
3690                 if (wpa_s->confname == NULL) {
3691                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
3692                                    "for configuration file '%s'.",
3693                                    iface->confname);
3694                         return -1;
3695                 }
3696                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
3697                            iface->confname, wpa_s->confname);
3698 #else /* CONFIG_BACKEND_FILE */
3699                 wpa_s->confname = os_strdup(iface->confname);
3700 #endif /* CONFIG_BACKEND_FILE */
3701                 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
3702                 if (wpa_s->conf == NULL) {
3703                         wpa_printf(MSG_ERROR, "Failed to read or parse "
3704                                    "configuration '%s'.", wpa_s->confname);
3705                         return -1;
3706                 }
3707                 wpa_s->confanother = os_rel2abs_path(iface->confanother);
3708                 wpa_config_read(wpa_s->confanother, wpa_s->conf);
3709
3710                 /*
3711                  * Override ctrl_interface and driver_param if set on command
3712                  * line.
3713                  */
3714                 if (iface->ctrl_interface) {
3715                         os_free(wpa_s->conf->ctrl_interface);
3716                         wpa_s->conf->ctrl_interface =
3717                                 os_strdup(iface->ctrl_interface);
3718                 }
3719
3720                 if (iface->driver_param) {
3721                         os_free(wpa_s->conf->driver_param);
3722                         wpa_s->conf->driver_param =
3723                                 os_strdup(iface->driver_param);
3724                 }
3725
3726                 if (iface->p2p_mgmt && !iface->ctrl_interface) {
3727                         os_free(wpa_s->conf->ctrl_interface);
3728                         wpa_s->conf->ctrl_interface = NULL;
3729                 }
3730         } else
3731                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
3732                                                      iface->driver_param);
3733
3734         if (wpa_s->conf == NULL) {
3735                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
3736                 return -1;
3737         }
3738
3739         if (iface->ifname == NULL) {
3740                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
3741                 return -1;
3742         }
3743         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
3744                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
3745                            iface->ifname);
3746                 return -1;
3747         }
3748         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
3749
3750         if (iface->bridge_ifname) {
3751                 if (os_strlen(iface->bridge_ifname) >=
3752                     sizeof(wpa_s->bridge_ifname)) {
3753                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
3754                                    "name '%s'.", iface->bridge_ifname);
3755                         return -1;
3756                 }
3757                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
3758                            sizeof(wpa_s->bridge_ifname));
3759         }
3760
3761         /* RSNA Supplicant Key Management - INITIALIZE */
3762         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
3763         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
3764
3765         /* Initialize driver interface and register driver event handler before
3766          * L2 receive handler so that association events are processed before
3767          * EAPOL-Key packets if both become available for the same select()
3768          * call. */
3769         if (wpas_init_driver(wpa_s, iface) < 0)
3770                 return -1;
3771
3772         if (wpa_supplicant_init_wpa(wpa_s) < 0)
3773                 return -1;
3774
3775         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
3776                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
3777                           NULL);
3778         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
3779
3780         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
3781             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
3782                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
3783                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3784                         "dot11RSNAConfigPMKLifetime");
3785                 return -1;
3786         }
3787
3788         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
3789             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
3790                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
3791                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3792                         "dot11RSNAConfigPMKReauthThreshold");
3793                 return -1;
3794         }
3795
3796         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
3797             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
3798                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
3799                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3800                         "dot11RSNAConfigSATimeout");
3801                 return -1;
3802         }
3803
3804         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
3805                                                       &wpa_s->hw.num_modes,
3806                                                       &wpa_s->hw.flags);
3807
3808         capa_res = wpa_drv_get_capa(wpa_s, &capa);
3809         if (capa_res == 0) {
3810                 wpa_s->drv_capa_known = 1;
3811                 wpa_s->drv_flags = capa.flags;
3812                 wpa_s->drv_enc = capa.enc;
3813                 wpa_s->drv_smps_modes = capa.smps_modes;
3814                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
3815                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
3816                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
3817                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
3818                 wpa_s->max_match_sets = capa.max_match_sets;
3819                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
3820                 wpa_s->max_stations = capa.max_stations;
3821                 wpa_s->extended_capa = capa.extended_capa;
3822                 wpa_s->extended_capa_mask = capa.extended_capa_mask;
3823                 wpa_s->extended_capa_len = capa.extended_capa_len;
3824                 wpa_s->num_multichan_concurrent =
3825                         capa.num_multichan_concurrent;
3826         }
3827         if (wpa_s->max_remain_on_chan == 0)
3828                 wpa_s->max_remain_on_chan = 1000;
3829
3830         /*
3831          * Only take p2p_mgmt parameters when P2P Device is supported.
3832          * Doing it here as it determines whether l2_packet_init() will be done
3833          * during wpa_supplicant_driver_init().
3834          */
3835         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3836                 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3837         else
3838                 iface->p2p_mgmt = 1;
3839
3840         if (wpa_s->num_multichan_concurrent == 0)
3841                 wpa_s->num_multichan_concurrent = 1;
3842
3843         if (wpa_supplicant_driver_init(wpa_s) < 0)
3844                 return -1;
3845
3846 #ifdef CONFIG_TDLS
3847         if ((!iface->p2p_mgmt ||
3848              !(wpa_s->drv_flags &
3849                WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3850             wpa_tdls_init(wpa_s->wpa))
3851                 return -1;
3852 #endif /* CONFIG_TDLS */
3853
3854         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3855             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3856                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3857                 return -1;
3858         }
3859
3860         if (wpas_wps_init(wpa_s))
3861                 return -1;
3862
3863         if (wpa_supplicant_init_eapol(wpa_s) < 0)
3864                 return -1;
3865         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3866
3867         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3868         if (wpa_s->ctrl_iface == NULL) {
3869                 wpa_printf(MSG_ERROR,
3870                            "Failed to initialize control interface '%s'.\n"
3871                            "You may have another wpa_supplicant process "
3872                            "already running or the file was\n"
3873                            "left by an unclean termination of wpa_supplicant "
3874                            "in which case you will need\n"
3875                            "to manually remove this file before starting "
3876                            "wpa_supplicant again.\n",
3877                            wpa_s->conf->ctrl_interface);
3878                 return -1;
3879         }
3880
3881         wpa_s->gas = gas_query_init(wpa_s);
3882         if (wpa_s->gas == NULL) {
3883                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
3884                 return -1;
3885         }
3886
3887         if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
3888                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3889                 return -1;
3890         }
3891
3892         if (wpa_bss_init(wpa_s) < 0)
3893                 return -1;
3894
3895         /*
3896          * Set Wake-on-WLAN triggers, if configured.
3897          * Note: We don't restore/remove the triggers on shutdown (it doesn't
3898          * have effect anyway when the interface is down).
3899          */
3900         if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
3901                 return -1;
3902
3903 #ifdef CONFIG_EAP_PROXY
3904 {
3905         size_t len;
3906         wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
3907                                                      &len);
3908         if (wpa_s->mnc_len > 0) {
3909                 wpa_s->imsi[len] = '\0';
3910                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
3911                            wpa_s->imsi, wpa_s->mnc_len);
3912         } else {
3913                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
3914         }
3915 }
3916 #endif /* CONFIG_EAP_PROXY */
3917
3918         if (pcsc_reader_init(wpa_s) < 0)
3919                 return -1;
3920
3921         if (wpas_init_ext_pw(wpa_s) < 0)
3922                 return -1;
3923
3924         return 0;
3925 }
3926
3927
3928 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
3929                                         int notify, int terminate)
3930 {
3931         struct wpa_global *global = wpa_s->global;
3932         struct wpa_supplicant *iface, *prev;
3933
3934         if (wpa_s == wpa_s->parent)
3935                 wpas_p2p_group_remove(wpa_s, "*");
3936
3937         iface = global->ifaces;
3938         while (iface) {
3939                 if (iface == wpa_s || iface->parent != wpa_s) {
3940                         iface = iface->next;
3941                         continue;
3942                 }
3943                 wpa_printf(MSG_DEBUG,
3944                            "Remove remaining child interface %s from parent %s",
3945                            iface->ifname, wpa_s->ifname);
3946                 prev = iface;
3947                 iface = iface->next;
3948                 wpa_supplicant_remove_iface(global, prev, terminate);
3949         }
3950
3951         wpa_s->disconnected = 1;
3952         if (wpa_s->drv_priv) {
3953                 wpa_supplicant_deauthenticate(wpa_s,
3954                                               WLAN_REASON_DEAUTH_LEAVING);
3955
3956                 wpa_drv_set_countermeasures(wpa_s, 0);
3957                 wpa_clear_keys(wpa_s, NULL);
3958         }
3959
3960         wpa_supplicant_cleanup(wpa_s);
3961         wpas_p2p_deinit_iface(wpa_s);
3962
3963         wpas_ctrl_radio_work_flush(wpa_s);
3964         radio_remove_interface(wpa_s);
3965
3966         if (wpa_s->drv_priv)
3967                 wpa_drv_deinit(wpa_s);
3968
3969         if (notify)
3970                 wpas_notify_iface_removed(wpa_s);
3971
3972         if (terminate)
3973                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3974
3975         if (wpa_s->ctrl_iface) {
3976                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3977                 wpa_s->ctrl_iface = NULL;
3978         }
3979
3980         if (wpa_s->conf != NULL) {
3981                 wpa_config_free(wpa_s->conf);
3982                 wpa_s->conf = NULL;
3983         }
3984
3985         os_free(wpa_s);
3986 }
3987
3988
3989 /**
3990  * wpa_supplicant_add_iface - Add a new network interface
3991  * @global: Pointer to global data from wpa_supplicant_init()
3992  * @iface: Interface configuration options
3993  * Returns: Pointer to the created interface or %NULL on failure
3994  *
3995  * This function is used to add new network interfaces for %wpa_supplicant.
3996  * This can be called before wpa_supplicant_run() to add interfaces before the
3997  * main event loop has been started. In addition, new interfaces can be added
3998  * dynamically while %wpa_supplicant is already running. This could happen,
3999  * e.g., when a hotplug network adapter is inserted.
4000  */
4001 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
4002                                                  struct wpa_interface *iface)
4003 {
4004         struct wpa_supplicant *wpa_s;
4005         struct wpa_interface t_iface;
4006         struct wpa_ssid *ssid;
4007
4008         if (global == NULL || iface == NULL)
4009                 return NULL;
4010
4011         wpa_s = wpa_supplicant_alloc();
4012         if (wpa_s == NULL)
4013                 return NULL;
4014
4015         wpa_s->global = global;
4016
4017         t_iface = *iface;
4018         if (global->params.override_driver) {
4019                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
4020                            "('%s' -> '%s')",
4021                            iface->driver, global->params.override_driver);
4022                 t_iface.driver = global->params.override_driver;
4023         }
4024         if (global->params.override_ctrl_interface) {
4025                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
4026                            "ctrl_interface ('%s' -> '%s')",
4027                            iface->ctrl_interface,
4028                            global->params.override_ctrl_interface);
4029                 t_iface.ctrl_interface =
4030                         global->params.override_ctrl_interface;
4031         }
4032         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
4033                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
4034                            iface->ifname);
4035                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
4036                 return NULL;
4037         }
4038
4039         if (iface->p2p_mgmt == 0) {
4040                 /* Notify the control interfaces about new iface */
4041                 if (wpas_notify_iface_added(wpa_s)) {
4042                         wpa_supplicant_deinit_iface(wpa_s, 1, 0);
4043                         return NULL;
4044                 }
4045
4046                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
4047                         wpas_notify_network_added(wpa_s, ssid);
4048         }
4049
4050         wpa_s->next = global->ifaces;
4051         global->ifaces = wpa_s;
4052
4053         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
4054         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
4055
4056 #ifdef CONFIG_P2P
4057         if (wpa_s->global->p2p == NULL &&
4058             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
4059             wpas_p2p_add_p2pdev_interface(wpa_s, iface->conf_p2p_dev) < 0) {
4060                 wpa_printf(MSG_INFO,
4061                            "P2P: Failed to enable P2P Device interface");
4062                 /* Try to continue without. P2P will be disabled. */
4063         }
4064 #endif /* CONFIG_P2P */
4065
4066         return wpa_s;
4067 }
4068
4069
4070 /**
4071  * wpa_supplicant_remove_iface - Remove a network interface
4072  * @global: Pointer to global data from wpa_supplicant_init()
4073  * @wpa_s: Pointer to the network interface to be removed
4074  * Returns: 0 if interface was removed, -1 if interface was not found
4075  *
4076  * This function can be used to dynamically remove network interfaces from
4077  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
4078  * addition, this function is used to remove all remaining interfaces when
4079  * %wpa_supplicant is terminated.
4080  */
4081 int wpa_supplicant_remove_iface(struct wpa_global *global,
4082                                 struct wpa_supplicant *wpa_s,
4083                                 int terminate)
4084 {
4085         struct wpa_supplicant *prev;
4086
4087         /* Remove interface from the global list of interfaces */
4088         prev = global->ifaces;
4089         if (prev == wpa_s) {
4090                 global->ifaces = wpa_s->next;
4091         } else {
4092                 while (prev && prev->next != wpa_s)
4093                         prev = prev->next;
4094                 if (prev == NULL)
4095                         return -1;
4096                 prev->next = wpa_s->next;
4097         }
4098
4099         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
4100
4101         if (global->p2p_group_formation == wpa_s)
4102                 global->p2p_group_formation = NULL;
4103         if (global->p2p_invite_group == wpa_s)
4104                 global->p2p_invite_group = NULL;
4105         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
4106
4107         return 0;
4108 }
4109
4110
4111 /**
4112  * wpa_supplicant_get_eap_mode - Get the current EAP mode
4113  * @wpa_s: Pointer to the network interface
4114  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
4115  */
4116 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
4117 {
4118         const char *eapol_method;
4119
4120         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
4121             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
4122                 return "NO-EAP";
4123         }
4124
4125         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
4126         if (eapol_method == NULL)
4127                 return "UNKNOWN-EAP";
4128
4129         return eapol_method;
4130 }
4131
4132
4133 /**
4134  * wpa_supplicant_get_iface - Get a new network interface
4135  * @global: Pointer to global data from wpa_supplicant_init()
4136  * @ifname: Interface name
4137  * Returns: Pointer to the interface or %NULL if not found
4138  */
4139 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
4140                                                  const char *ifname)
4141 {
4142         struct wpa_supplicant *wpa_s;
4143
4144         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4145                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
4146                         return wpa_s;
4147         }
4148         return NULL;
4149 }
4150
4151
4152 #ifndef CONFIG_NO_WPA_MSG
4153 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
4154 {
4155         struct wpa_supplicant *wpa_s = ctx;
4156         if (wpa_s == NULL)
4157                 return NULL;
4158         return wpa_s->ifname;
4159 }
4160 #endif /* CONFIG_NO_WPA_MSG */
4161
4162
4163 /**
4164  * wpa_supplicant_init - Initialize %wpa_supplicant
4165  * @params: Parameters for %wpa_supplicant
4166  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
4167  *
4168  * This function is used to initialize %wpa_supplicant. After successful
4169  * initialization, the returned data pointer can be used to add and remove
4170  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
4171  */
4172 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
4173 {
4174         struct wpa_global *global;
4175         int ret, i;
4176
4177         if (params == NULL)
4178                 return NULL;
4179
4180 #ifdef CONFIG_DRIVER_NDIS
4181         {
4182                 void driver_ndis_init_ops(void);
4183                 driver_ndis_init_ops();
4184         }
4185 #endif /* CONFIG_DRIVER_NDIS */
4186
4187 #ifndef CONFIG_NO_WPA_MSG
4188         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
4189 #endif /* CONFIG_NO_WPA_MSG */
4190
4191         wpa_debug_open_file(params->wpa_debug_file_path);
4192         if (params->wpa_debug_syslog)
4193                 wpa_debug_open_syslog();
4194         if (params->wpa_debug_tracing) {
4195                 ret = wpa_debug_open_linux_tracing();
4196                 if (ret) {
4197                         wpa_printf(MSG_ERROR,
4198                                    "Failed to enable trace logging");
4199                         return NULL;
4200                 }
4201         }
4202
4203         ret = eap_register_methods();
4204         if (ret) {
4205                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
4206                 if (ret == -2)
4207                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
4208                                    "the same EAP type.");
4209                 return NULL;
4210         }
4211
4212         global = os_zalloc(sizeof(*global));
4213         if (global == NULL)
4214                 return NULL;
4215         dl_list_init(&global->p2p_srv_bonjour);
4216         dl_list_init(&global->p2p_srv_upnp);
4217         global->params.daemonize = params->daemonize;
4218         global->params.wait_for_monitor = params->wait_for_monitor;
4219         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
4220         if (params->pid_file)
4221                 global->params.pid_file = os_strdup(params->pid_file);
4222         if (params->ctrl_interface)
4223                 global->params.ctrl_interface =
4224                         os_strdup(params->ctrl_interface);
4225         if (params->ctrl_interface_group)
4226                 global->params.ctrl_interface_group =
4227                         os_strdup(params->ctrl_interface_group);
4228         if (params->override_driver)
4229                 global->params.override_driver =
4230                         os_strdup(params->override_driver);
4231         if (params->override_ctrl_interface)
4232                 global->params.override_ctrl_interface =
4233                         os_strdup(params->override_ctrl_interface);
4234         wpa_debug_level = global->params.wpa_debug_level =
4235                 params->wpa_debug_level;
4236         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
4237                 params->wpa_debug_show_keys;
4238         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
4239                 params->wpa_debug_timestamp;
4240
4241         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
4242
4243         if (eloop_init()) {
4244                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
4245                 wpa_supplicant_deinit(global);
4246                 return NULL;
4247         }
4248
4249         random_init(params->entropy_file);
4250
4251         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
4252         if (global->ctrl_iface == NULL) {
4253                 wpa_supplicant_deinit(global);
4254                 return NULL;
4255         }
4256
4257         if (wpas_notify_supplicant_initialized(global)) {
4258                 wpa_supplicant_deinit(global);
4259                 return NULL;
4260         }
4261
4262         for (i = 0; wpa_drivers[i]; i++)
4263                 global->drv_count++;
4264         if (global->drv_count == 0) {
4265                 wpa_printf(MSG_ERROR, "No drivers enabled");
4266                 wpa_supplicant_deinit(global);
4267                 return NULL;
4268         }
4269         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
4270         if (global->drv_priv == NULL) {
4271                 wpa_supplicant_deinit(global);
4272                 return NULL;
4273         }
4274
4275 #ifdef CONFIG_WIFI_DISPLAY
4276         if (wifi_display_init(global) < 0) {
4277                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
4278                 wpa_supplicant_deinit(global);
4279                 return NULL;
4280         }
4281 #endif /* CONFIG_WIFI_DISPLAY */
4282
4283         return global;
4284 }
4285
4286
4287 /**
4288  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
4289  * @global: Pointer to global data from wpa_supplicant_init()
4290  * Returns: 0 after successful event loop run, -1 on failure
4291  *
4292  * This function starts the main event loop and continues running as long as
4293  * there are any remaining events. In most cases, this function is running as
4294  * long as the %wpa_supplicant process in still in use.
4295  */
4296 int wpa_supplicant_run(struct wpa_global *global)
4297 {
4298         struct wpa_supplicant *wpa_s;
4299
4300         if (global->params.daemonize &&
4301             wpa_supplicant_daemon(global->params.pid_file))
4302                 return -1;
4303
4304         if (global->params.wait_for_monitor) {
4305                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
4306                         if (wpa_s->ctrl_iface)
4307                                 wpa_supplicant_ctrl_iface_wait(
4308                                         wpa_s->ctrl_iface);
4309         }
4310
4311         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
4312         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
4313
4314         eloop_run();
4315
4316         return 0;
4317 }
4318
4319
4320 /**
4321  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
4322  * @global: Pointer to global data from wpa_supplicant_init()
4323  *
4324  * This function is called to deinitialize %wpa_supplicant and to free all
4325  * allocated resources. Remaining network interfaces will also be removed.
4326  */
4327 void wpa_supplicant_deinit(struct wpa_global *global)
4328 {
4329         int i;
4330
4331         if (global == NULL)
4332                 return;
4333
4334 #ifdef CONFIG_WIFI_DISPLAY
4335         wifi_display_deinit(global);
4336 #endif /* CONFIG_WIFI_DISPLAY */
4337
4338         while (global->ifaces)
4339                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
4340
4341         if (global->ctrl_iface)
4342                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
4343
4344         wpas_notify_supplicant_deinitialized(global);
4345
4346         eap_peer_unregister_methods();
4347 #ifdef CONFIG_AP
4348         eap_server_unregister_methods();
4349 #endif /* CONFIG_AP */
4350
4351         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
4352                 if (!global->drv_priv[i])
4353                         continue;
4354                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
4355         }
4356         os_free(global->drv_priv);
4357
4358         random_deinit();
4359
4360         eloop_destroy();
4361
4362         if (global->params.pid_file) {
4363                 os_daemonize_terminate(global->params.pid_file);
4364                 os_free(global->params.pid_file);
4365         }
4366         os_free(global->params.ctrl_interface);
4367         os_free(global->params.ctrl_interface_group);
4368         os_free(global->params.override_driver);
4369         os_free(global->params.override_ctrl_interface);
4370
4371         os_free(global->p2p_disallow_freq.range);
4372         os_free(global->p2p_go_avoid_freq.range);
4373         os_free(global->add_psk);
4374
4375         os_free(global);
4376         wpa_debug_close_syslog();
4377         wpa_debug_close_file();
4378         wpa_debug_close_linux_tracing();
4379 }
4380
4381
4382 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
4383 {
4384         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
4385             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4386                 char country[3];
4387                 country[0] = wpa_s->conf->country[0];
4388                 country[1] = wpa_s->conf->country[1];
4389                 country[2] = '\0';
4390                 if (wpa_drv_set_country(wpa_s, country) < 0) {
4391                         wpa_printf(MSG_ERROR, "Failed to set country code "
4392                                    "'%s'", country);
4393                 }
4394         }
4395
4396         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
4397                 wpas_init_ext_pw(wpa_s);
4398
4399 #ifdef CONFIG_WPS
4400         wpas_wps_update_config(wpa_s);
4401 #endif /* CONFIG_WPS */
4402         wpas_p2p_update_config(wpa_s);
4403         wpa_s->conf->changed_parameters = 0;
4404 }
4405
4406
4407 static void add_freq(int *freqs, int *num_freqs, int freq)
4408 {
4409         int i;
4410
4411         for (i = 0; i < *num_freqs; i++) {
4412                 if (freqs[i] == freq)
4413                         return;
4414         }
4415
4416         freqs[*num_freqs] = freq;
4417         (*num_freqs)++;
4418 }
4419
4420
4421 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
4422 {
4423         struct wpa_bss *bss, *cbss;
4424         const int max_freqs = 10;
4425         int *freqs;
4426         int num_freqs = 0;
4427
4428         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
4429         if (freqs == NULL)
4430                 return NULL;
4431
4432         cbss = wpa_s->current_bss;
4433
4434         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
4435                 if (bss == cbss)
4436                         continue;
4437                 if (bss->ssid_len == cbss->ssid_len &&
4438                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
4439                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
4440                         add_freq(freqs, &num_freqs, bss->freq);
4441                         if (num_freqs == max_freqs)
4442                                 break;
4443                 }
4444         }
4445
4446         if (num_freqs == 0) {
4447                 os_free(freqs);
4448                 freqs = NULL;
4449         }
4450
4451         return freqs;
4452 }
4453
4454
4455 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
4456 {
4457         int timeout;
4458         int count;
4459         int *freqs = NULL;
4460
4461         wpas_connect_work_done(wpa_s);
4462
4463         /*
4464          * Remove possible authentication timeout since the connection failed.
4465          */
4466         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4467
4468         if (wpa_s->disconnected) {
4469                 /*
4470                  * There is no point in blacklisting the AP if this event is
4471                  * generated based on local request to disconnect.
4472                  */
4473                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
4474                         "indication since interface has been put into "
4475                         "disconnected state");
4476                 return;
4477         }
4478
4479         /*
4480          * Add the failed BSSID into the blacklist and speed up next scan
4481          * attempt if there could be other APs that could accept association.
4482          * The current blacklist count indicates how many times we have tried
4483          * connecting to this AP and multiple attempts mean that other APs are
4484          * either not available or has already been tried, so that we can start
4485          * increasing the delay here to avoid constant scanning.
4486          */
4487         count = wpa_blacklist_add(wpa_s, bssid);
4488         if (count == 1 && wpa_s->current_bss) {
4489                 /*
4490                  * This BSS was not in the blacklist before. If there is
4491                  * another BSS available for the same ESS, we should try that
4492                  * next. Otherwise, we may as well try this one once more
4493                  * before allowing other, likely worse, ESSes to be considered.
4494                  */
4495                 freqs = get_bss_freqs_in_ess(wpa_s);
4496                 if (freqs) {
4497                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
4498                                 "has been seen; try it next");
4499                         wpa_blacklist_add(wpa_s, bssid);
4500                         /*
4501                          * On the next scan, go through only the known channels
4502                          * used in this ESS based on previous scans to speed up
4503                          * common load balancing use case.
4504                          */
4505                         os_free(wpa_s->next_scan_freqs);
4506                         wpa_s->next_scan_freqs = freqs;
4507                 }
4508         }
4509
4510         /*
4511          * Add previous failure count in case the temporary blacklist was
4512          * cleared due to no other BSSes being available.
4513          */
4514         count += wpa_s->extra_blacklist_count;
4515
4516         if (count > 3 && wpa_s->current_ssid) {
4517                 wpa_printf(MSG_DEBUG, "Continuous association failures - "
4518                            "consider temporary network disabling");
4519                 wpas_auth_failed(wpa_s, "CONN_FAILED");
4520         }
4521
4522         switch (count) {
4523         case 1:
4524                 timeout = 100;
4525                 break;
4526         case 2:
4527                 timeout = 500;
4528                 break;
4529         case 3:
4530                 timeout = 1000;
4531                 break;
4532         case 4:
4533                 timeout = 5000;
4534                 break;
4535         default:
4536                 timeout = 10000;
4537                 break;
4538         }
4539
4540         wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
4541                 "ms", count, timeout);
4542
4543         /*
4544          * TODO: if more than one possible AP is available in scan results,
4545          * could try the other ones before requesting a new scan.
4546          */
4547         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
4548                                 1000 * (timeout % 1000));
4549 }
4550
4551
4552 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
4553 {
4554         return wpa_s->conf->ap_scan == 2 ||
4555                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
4556 }
4557
4558
4559 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
4560 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
4561                                               struct wpa_ssid *ssid,
4562                                               const char *field,
4563                                               const char *value)
4564 {
4565 #ifdef IEEE8021X_EAPOL
4566         struct eap_peer_config *eap = &ssid->eap;
4567
4568         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
4569         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
4570                               (const u8 *) value, os_strlen(value));
4571
4572         switch (wpa_supplicant_ctrl_req_from_string(field)) {
4573         case WPA_CTRL_REQ_EAP_IDENTITY:
4574                 os_free(eap->identity);
4575                 eap->identity = (u8 *) os_strdup(value);
4576                 eap->identity_len = os_strlen(value);
4577                 eap->pending_req_identity = 0;
4578                 if (ssid == wpa_s->current_ssid)
4579                         wpa_s->reassociate = 1;
4580                 break;
4581         case WPA_CTRL_REQ_EAP_PASSWORD:
4582                 bin_clear_free(eap->password, eap->password_len);
4583                 eap->password = (u8 *) os_strdup(value);
4584                 eap->password_len = os_strlen(value);
4585                 eap->pending_req_password = 0;
4586                 if (ssid == wpa_s->current_ssid)
4587                         wpa_s->reassociate = 1;
4588                 break;
4589         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
4590                 bin_clear_free(eap->new_password, eap->new_password_len);
4591                 eap->new_password = (u8 *) os_strdup(value);
4592                 eap->new_password_len = os_strlen(value);
4593                 eap->pending_req_new_password = 0;
4594                 if (ssid == wpa_s->current_ssid)
4595                         wpa_s->reassociate = 1;
4596                 break;
4597         case WPA_CTRL_REQ_EAP_PIN:
4598                 str_clear_free(eap->pin);
4599                 eap->pin = os_strdup(value);
4600                 eap->pending_req_pin = 0;
4601                 if (ssid == wpa_s->current_ssid)
4602                         wpa_s->reassociate = 1;
4603                 break;
4604         case WPA_CTRL_REQ_EAP_OTP:
4605                 bin_clear_free(eap->otp, eap->otp_len);
4606                 eap->otp = (u8 *) os_strdup(value);
4607                 eap->otp_len = os_strlen(value);
4608                 os_free(eap->pending_req_otp);
4609                 eap->pending_req_otp = NULL;
4610                 eap->pending_req_otp_len = 0;
4611                 break;
4612         case WPA_CTRL_REQ_EAP_PASSPHRASE:
4613                 str_clear_free(eap->private_key_passwd);
4614                 eap->private_key_passwd = os_strdup(value);
4615                 eap->pending_req_passphrase = 0;
4616                 if (ssid == wpa_s->current_ssid)
4617                         wpa_s->reassociate = 1;
4618                 break;
4619         case WPA_CTRL_REQ_SIM:
4620                 str_clear_free(eap->external_sim_resp);
4621                 eap->external_sim_resp = os_strdup(value);
4622                 break;
4623         default:
4624                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
4625                 return -1;
4626         }
4627
4628         return 0;
4629 #else /* IEEE8021X_EAPOL */
4630         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
4631         return -1;
4632 #endif /* IEEE8021X_EAPOL */
4633 }
4634 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
4635
4636
4637 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
4638 {
4639         int i;
4640         unsigned int drv_enc;
4641
4642         if (ssid == NULL)
4643                 return 1;
4644
4645         if (ssid->disabled)
4646                 return 1;
4647
4648         if (wpa_s && wpa_s->drv_capa_known)
4649                 drv_enc = wpa_s->drv_enc;
4650         else
4651                 drv_enc = (unsigned int) -1;
4652
4653         for (i = 0; i < NUM_WEP_KEYS; i++) {
4654                 size_t len = ssid->wep_key_len[i];
4655                 if (len == 0)
4656                         continue;
4657                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
4658                         continue;
4659                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
4660                         continue;
4661                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
4662                         continue;
4663                 return 1; /* invalid WEP key */
4664         }
4665
4666         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
4667             (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk)
4668                 return 1;
4669
4670         return 0;
4671 }
4672
4673
4674 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
4675 {
4676         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
4677                 return 1;
4678         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
4679                 return 0;
4680         return -1;
4681 }
4682
4683
4684 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
4685 {
4686         struct wpa_ssid *ssid = wpa_s->current_ssid;
4687         int dur;
4688         struct os_reltime now;
4689
4690         if (ssid == NULL) {
4691                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
4692                            "SSID block");
4693                 return;
4694         }
4695
4696         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
4697                 return;
4698
4699         ssid->auth_failures++;
4700
4701 #ifdef CONFIG_P2P
4702         if (ssid->p2p_group &&
4703             (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
4704                 /*
4705                  * Skip the wait time since there is a short timeout on the
4706                  * connection to a P2P group.
4707                  */
4708                 return;
4709         }
4710 #endif /* CONFIG_P2P */
4711
4712         if (ssid->auth_failures > 50)
4713                 dur = 300;
4714         else if (ssid->auth_failures > 10)
4715                 dur = 120;
4716         else if (ssid->auth_failures > 5)
4717                 dur = 90;
4718         else if (ssid->auth_failures > 3)
4719                 dur = 60;
4720         else if (ssid->auth_failures > 2)
4721                 dur = 30;
4722         else if (ssid->auth_failures > 1)
4723                 dur = 20;
4724         else
4725                 dur = 10;
4726
4727         if (ssid->auth_failures > 1 &&
4728             wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
4729                 dur += os_random() % (ssid->auth_failures * 10);
4730
4731         os_get_reltime(&now);
4732         if (now.sec + dur <= ssid->disabled_until.sec)
4733                 return;
4734
4735         ssid->disabled_until.sec = now.sec + dur;
4736
4737         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
4738                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
4739                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
4740                 ssid->auth_failures, dur, reason);
4741 }
4742
4743
4744 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
4745                               struct wpa_ssid *ssid, int clear_failures)
4746 {
4747         if (ssid == NULL)
4748                 return;
4749
4750         if (ssid->disabled_until.sec) {
4751                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
4752                         "id=%d ssid=\"%s\"",
4753                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
4754         }
4755         ssid->disabled_until.sec = 0;
4756         ssid->disabled_until.usec = 0;
4757         if (clear_failures)
4758                 ssid->auth_failures = 0;
4759 }
4760
4761
4762 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
4763 {
4764         size_t i;
4765
4766         if (wpa_s->disallow_aps_bssid == NULL)
4767                 return 0;
4768
4769         for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
4770                 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
4771                               bssid, ETH_ALEN) == 0)
4772                         return 1;
4773         }
4774
4775         return 0;
4776 }
4777
4778
4779 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
4780                     size_t ssid_len)
4781 {
4782         size_t i;
4783
4784         if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
4785                 return 0;
4786
4787         for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
4788                 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
4789                 if (ssid_len == s->ssid_len &&
4790                     os_memcmp(ssid, s->ssid, ssid_len) == 0)
4791                         return 1;
4792         }
4793
4794         return 0;
4795 }
4796
4797
4798 /**
4799  * wpas_request_connection - Request a new connection
4800  * @wpa_s: Pointer to the network interface
4801  *
4802  * This function is used to request a new connection to be found. It will mark
4803  * the interface to allow reassociation and request a new scan to find a
4804  * suitable network to connect to.
4805  */
4806 void wpas_request_connection(struct wpa_supplicant *wpa_s)
4807 {
4808         wpa_s->normal_scans = 0;
4809         wpa_supplicant_reinit_autoscan(wpa_s);
4810         wpa_s->extra_blacklist_count = 0;
4811         wpa_s->disconnected = 0;
4812         wpa_s->reassociate = 1;
4813
4814         if (wpa_supplicant_fast_associate(wpa_s) != 1)
4815                 wpa_supplicant_req_scan(wpa_s, 0, 0);
4816 }
4817
4818
4819 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
4820                     struct wpa_used_freq_data *freqs_data,
4821                     unsigned int len)
4822 {
4823         unsigned int i;
4824
4825         wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
4826                 len, title);
4827         for (i = 0; i < len; i++) {
4828                 struct wpa_used_freq_data *cur = &freqs_data[i];
4829                 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
4830                         i, cur->freq, cur->flags);
4831         }
4832 }
4833
4834
4835 /*
4836  * Find the operating frequencies of any of the virtual interfaces that
4837  * are using the same radio as the current interface, and in addition, get
4838  * information about the interface types that are using the frequency.
4839  */
4840 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
4841                                 struct wpa_used_freq_data *freqs_data,
4842                                 unsigned int len)
4843 {
4844         struct wpa_supplicant *ifs;
4845         u8 bssid[ETH_ALEN];
4846         int freq;
4847         unsigned int idx = 0, i;
4848
4849         wpa_dbg(wpa_s, MSG_DEBUG,
4850                 "Determining shared radio frequencies (max len %u)", len);
4851         os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
4852
4853         dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4854                          radio_list) {
4855                 if (idx == len)
4856                         break;
4857
4858                 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
4859                         continue;
4860
4861                 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
4862                     ifs->current_ssid->mode == WPAS_MODE_P2P_GO)
4863                         freq = ifs->current_ssid->frequency;
4864                 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
4865                         freq = ifs->assoc_freq;
4866                 else
4867                         continue;
4868
4869                 /* Hold only distinct freqs */
4870                 for (i = 0; i < idx; i++)
4871                         if (freqs_data[i].freq == freq)
4872                                 break;
4873
4874                 if (i == idx)
4875                         freqs_data[idx++].freq = freq;
4876
4877                 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
4878                         freqs_data[i].flags = ifs->current_ssid->p2p_group ?
4879                                 WPA_FREQ_USED_BY_P2P_CLIENT :
4880                                 WPA_FREQ_USED_BY_INFRA_STATION;
4881                 }
4882         }
4883
4884         dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
4885         return idx;
4886 }
4887
4888
4889 /*
4890  * Find the operating frequencies of any of the virtual interfaces that
4891  * are using the same radio as the current interface.
4892  */
4893 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4894                            int *freq_array, unsigned int len)
4895 {
4896         struct wpa_used_freq_data *freqs_data;
4897         int num, i;
4898
4899         os_memset(freq_array, 0, sizeof(int) * len);
4900
4901         freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
4902         if (!freqs_data)
4903                 return -1;
4904
4905         num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
4906         for (i = 0; i < num; i++)
4907                 freq_array[i] = freqs_data[i].freq;
4908
4909         os_free(freqs_data);
4910
4911         return num;
4912 }