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