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
2961         if (!ssid)
2962                 return;
2963
2964         params->disable_vht = ssid->disable_vht;
2965
2966         vhtcaps = (void *) params->vhtcaps;
2967         vhtcaps_mask = (void *) params->vhtcaps_mask;
2968
2969         if (!vhtcaps || !vhtcaps_mask)
2970                 return;
2971
2972         vhtcaps->vht_capabilities_info = ssid->vht_capa;
2973         vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask;
2974
2975 #define OVERRIDE_MCS(i)                                                 \
2976         if (ssid->vht_tx_mcs_nss_ ##i >= 0) {                           \
2977                 vhtcaps_mask->vht_supported_mcs_set.tx_map |=           \
2978                         3 << 2 * (i - 1);                               \
2979                 vhtcaps->vht_supported_mcs_set.tx_map |=                \
2980                         ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1);       \
2981         }                                                               \
2982         if (ssid->vht_rx_mcs_nss_ ##i >= 0) {                           \
2983                 vhtcaps_mask->vht_supported_mcs_set.rx_map |=           \
2984                         3 << 2 * (i - 1);                               \
2985                 vhtcaps->vht_supported_mcs_set.rx_map |=                \
2986                         ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1);       \
2987         }
2988
2989         OVERRIDE_MCS(1);
2990         OVERRIDE_MCS(2);
2991         OVERRIDE_MCS(3);
2992         OVERRIDE_MCS(4);
2993         OVERRIDE_MCS(5);
2994         OVERRIDE_MCS(6);
2995         OVERRIDE_MCS(7);
2996         OVERRIDE_MCS(8);
2997 }
2998 #endif /* CONFIG_VHT_OVERRIDES */
2999
3000
3001 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3002 {
3003 #ifdef PCSC_FUNCS
3004         size_t len;
3005
3006         if (!wpa_s->conf->pcsc_reader)
3007                 return 0;
3008
3009         wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3010         if (!wpa_s->scard)
3011                 return 1;
3012
3013         if (wpa_s->conf->pcsc_pin &&
3014             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3015                 scard_deinit(wpa_s->scard);
3016                 wpa_s->scard = NULL;
3017                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3018                 return -1;
3019         }
3020
3021         len = sizeof(wpa_s->imsi) - 1;
3022         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3023                 scard_deinit(wpa_s->scard);
3024                 wpa_s->scard = NULL;
3025                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3026                 return -1;
3027         }
3028         wpa_s->imsi[len] = '\0';
3029
3030         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3031
3032         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3033                    wpa_s->imsi, wpa_s->mnc_len);
3034
3035         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3036         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3037 #endif /* PCSC_FUNCS */
3038
3039         return 0;
3040 }
3041
3042
3043 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3044 {
3045         char *val, *pos;
3046
3047         ext_password_deinit(wpa_s->ext_pw);
3048         wpa_s->ext_pw = NULL;
3049         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3050
3051         if (!wpa_s->conf->ext_password_backend)
3052                 return 0;
3053
3054         val = os_strdup(wpa_s->conf->ext_password_backend);
3055         if (val == NULL)
3056                 return -1;
3057         pos = os_strchr(val, ':');
3058         if (pos)
3059                 *pos++ = '\0';
3060
3061         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
3062
3063         wpa_s->ext_pw = ext_password_init(val, pos);
3064         os_free(val);
3065         if (wpa_s->ext_pw == NULL) {
3066                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
3067                 return -1;
3068         }
3069         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3070
3071         return 0;
3072 }
3073
3074
3075 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
3076                                               const char *rn)
3077 {
3078         struct wpa_supplicant *iface = wpa_s->global->ifaces;
3079         struct wpa_radio *radio;
3080
3081         while (rn && iface) {
3082                 radio = iface->radio;
3083                 if (radio && os_strcmp(rn, radio->name) == 0) {
3084                         wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
3085                                    wpa_s->ifname, rn);
3086                         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3087                         return radio;
3088                 }
3089
3090                 iface = iface->next;
3091         }
3092
3093         wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
3094                    wpa_s->ifname, rn ? rn : "N/A");
3095         radio = os_zalloc(sizeof(*radio));
3096         if (radio == NULL)
3097                 return NULL;
3098
3099         if (rn)
3100                 os_strlcpy(radio->name, rn, sizeof(radio->name));
3101         dl_list_init(&radio->ifaces);
3102         dl_list_init(&radio->work);
3103         dl_list_add(&radio->ifaces, &wpa_s->radio_list);
3104
3105         return radio;
3106 }
3107
3108
3109 static void radio_work_free(struct wpa_radio_work *work)
3110 {
3111         if (work->wpa_s->scan_work == work) {
3112                 /* This should not really happen. */
3113                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3114                         work->type, work, work->started);
3115                 work->wpa_s->scan_work = NULL;
3116         }
3117
3118 #ifdef CONFIG_P2P
3119         if (work->wpa_s->p2p_scan_work == work) {
3120                 /* This should not really happen. */
3121                 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3122                         work->type, work, work->started);
3123                 work->wpa_s->p2p_scan_work = NULL;
3124         }
3125 #endif /* CONFIG_P2P */
3126
3127         dl_list_del(&work->list);
3128         os_free(work);
3129 }
3130
3131
3132 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
3133 {
3134         struct wpa_radio *radio = eloop_ctx;
3135         struct wpa_radio_work *work;
3136         struct os_reltime now, diff;
3137         struct wpa_supplicant *wpa_s;
3138
3139         work = dl_list_first(&radio->work, struct wpa_radio_work, list);
3140         if (work == NULL)
3141                 return;
3142
3143         if (work->started)
3144                 return; /* already started and still in progress */
3145
3146         wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
3147                               radio_list);
3148         if (wpa_s && wpa_s->external_scan_running) {
3149                 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
3150                 return;
3151         }
3152
3153         os_get_reltime(&now);
3154         os_reltime_sub(&now, &work->time, &diff);
3155         wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3156                 work->type, work, diff.sec, diff.usec);
3157         work->started = 1;
3158         work->time = now;
3159         work->cb(work, 0);
3160 }
3161
3162
3163 /*
3164  * This function removes both started and pending radio works running on
3165  * the provided interface's radio.
3166  * Prior to the removal of the radio work, its callback (cb) is called with
3167  * deinit set to be 1. Each work's callback is responsible for clearing its
3168  * internal data and restoring to a correct state.
3169  * @wpa_s: wpa_supplicant data
3170  * @type: type of works to be removed
3171  * @remove_all: 1 to remove all the works on this radio, 0 to remove only
3172  * this interface's works.
3173  */
3174 void radio_remove_works(struct wpa_supplicant *wpa_s,
3175                         const char *type, int remove_all)
3176 {
3177         struct wpa_radio_work *work, *tmp;
3178         struct wpa_radio *radio = wpa_s->radio;
3179
3180         dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
3181                               list) {
3182                 if (type && os_strcmp(type, work->type) != 0)
3183                         continue;
3184
3185                 /* skip other ifaces' works */
3186                 if (!remove_all && work->wpa_s != wpa_s)
3187                         continue;
3188
3189                 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
3190                         work->type, work, work->started ? " (started)" : "");
3191                 work->cb(work, 1);
3192                 radio_work_free(work);
3193         }
3194
3195         /* in case we removed the started work */
3196         radio_work_check_next(wpa_s);
3197 }
3198
3199
3200 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
3201 {
3202         struct wpa_radio *radio = wpa_s->radio;
3203
3204         if (!radio)
3205                 return;
3206
3207         wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
3208                    wpa_s->ifname, radio->name);
3209         dl_list_del(&wpa_s->radio_list);
3210         radio_remove_works(wpa_s, NULL, 0);
3211         wpa_s->radio = NULL;
3212         if (!dl_list_empty(&radio->ifaces))
3213                 return; /* Interfaces remain for this radio */
3214
3215         wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
3216         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3217         os_free(radio);
3218 }
3219
3220
3221 void radio_work_check_next(struct wpa_supplicant *wpa_s)
3222 {
3223         struct wpa_radio *radio = wpa_s->radio;
3224
3225         if (dl_list_empty(&radio->work))
3226                 return;
3227         eloop_cancel_timeout(radio_start_next_work, radio, NULL);
3228         eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
3229 }
3230
3231
3232 /**
3233  * radio_add_work - Add a radio work item
3234  * @wpa_s: Pointer to wpa_supplicant data
3235  * @freq: Frequency of the offchannel operation in MHz or 0
3236  * @type: Unique identifier for each type of work
3237  * @next: Force as the next work to be executed
3238  * @cb: Callback function for indicating when radio is available
3239  * @ctx: Context pointer for the work (work->ctx in cb())
3240  * Returns: 0 on success, -1 on failure
3241  *
3242  * This function is used to request time for an operation that requires
3243  * exclusive radio control. Once the radio is available, the registered callback
3244  * function will be called. radio_work_done() must be called once the exclusive
3245  * radio operation has been completed, so that the radio is freed for other
3246  * operations. The special case of deinit=1 is used to free the context data
3247  * during interface removal. That does not allow the callback function to start
3248  * the radio operation, i.e., it must free any resources allocated for the radio
3249  * work and return.
3250  *
3251  * The @freq parameter can be used to indicate a single channel on which the
3252  * offchannel operation will occur. This may allow multiple radio work
3253  * operations to be performed in parallel if they apply for the same channel.
3254  * Setting this to 0 indicates that the work item may use multiple channels or
3255  * requires exclusive control of the radio.
3256  */
3257 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
3258                    const char *type, int next,
3259                    void (*cb)(struct wpa_radio_work *work, int deinit),
3260                    void *ctx)
3261 {
3262         struct wpa_radio_work *work;
3263         int was_empty;
3264
3265         work = os_zalloc(sizeof(*work));
3266         if (work == NULL)
3267                 return -1;
3268         wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
3269         os_get_reltime(&work->time);
3270         work->freq = freq;
3271         work->type = type;
3272         work->wpa_s = wpa_s;
3273         work->cb = cb;
3274         work->ctx = ctx;
3275
3276         was_empty = dl_list_empty(&wpa_s->radio->work);
3277         if (next)
3278                 dl_list_add(&wpa_s->radio->work, &work->list);
3279         else
3280                 dl_list_add_tail(&wpa_s->radio->work, &work->list);
3281         if (was_empty) {
3282                 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
3283                 radio_work_check_next(wpa_s);
3284         }
3285
3286         return 0;
3287 }
3288
3289
3290 /**
3291  * radio_work_done - Indicate that a radio work item has been completed
3292  * @work: Completed work
3293  *
3294  * This function is called once the callback function registered with
3295  * radio_add_work() has completed its work.
3296  */
3297 void radio_work_done(struct wpa_radio_work *work)
3298 {
3299         struct wpa_supplicant *wpa_s = work->wpa_s;
3300         struct os_reltime now, diff;
3301         unsigned int started = work->started;
3302
3303         os_get_reltime(&now);
3304         os_reltime_sub(&now, &work->time, &diff);
3305         wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3306                 work->type, work, started ? "done" : "canceled",
3307                 diff.sec, diff.usec);
3308         radio_work_free(work);
3309         if (started)
3310                 radio_work_check_next(wpa_s);
3311 }
3312
3313
3314 int radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
3315 {
3316         struct wpa_radio_work *work;
3317         struct wpa_radio *radio = wpa_s->radio;
3318
3319         dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
3320                 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
3321                         return 1;
3322         }
3323
3324         return 0;
3325 }
3326
3327
3328 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
3329                             struct wpa_interface *iface)
3330 {
3331         const char *ifname, *driver, *rn;
3332
3333         driver = iface->driver;
3334 next_driver:
3335         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
3336                 return -1;
3337
3338         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
3339         if (wpa_s->drv_priv == NULL) {
3340                 const char *pos;
3341                 pos = driver ? os_strchr(driver, ',') : NULL;
3342                 if (pos) {
3343                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
3344                                 "driver interface - try next driver wrapper");
3345                         driver = pos + 1;
3346                         goto next_driver;
3347                 }
3348                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
3349                         "interface");
3350                 return -1;
3351         }
3352         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
3353                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
3354                         "driver_param '%s'", wpa_s->conf->driver_param);
3355                 return -1;
3356         }
3357
3358         ifname = wpa_drv_get_ifname(wpa_s);
3359         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
3360                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
3361                         "interface name with '%s'", ifname);
3362                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
3363         }
3364
3365         rn = wpa_driver_get_radio_name(wpa_s);
3366         if (rn && rn[0] == '\0')
3367                 rn = NULL;
3368
3369         wpa_s->radio = radio_add_interface(wpa_s, rn);
3370         if (wpa_s->radio == NULL)
3371                 return -1;
3372
3373         return 0;
3374 }
3375
3376
3377 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
3378                                      struct wpa_interface *iface)
3379 {
3380         struct wpa_driver_capa capa;
3381
3382         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
3383                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
3384                    iface->confname ? iface->confname : "N/A",
3385                    iface->driver ? iface->driver : "default",
3386                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
3387                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
3388
3389         if (iface->confname) {
3390 #ifdef CONFIG_BACKEND_FILE
3391                 wpa_s->confname = os_rel2abs_path(iface->confname);
3392                 if (wpa_s->confname == NULL) {
3393                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
3394                                    "for configuration file '%s'.",
3395                                    iface->confname);
3396                         return -1;
3397                 }
3398                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
3399                            iface->confname, wpa_s->confname);
3400 #else /* CONFIG_BACKEND_FILE */
3401                 wpa_s->confname = os_strdup(iface->confname);
3402 #endif /* CONFIG_BACKEND_FILE */
3403                 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
3404                 if (wpa_s->conf == NULL) {
3405                         wpa_printf(MSG_ERROR, "Failed to read or parse "
3406                                    "configuration '%s'.", wpa_s->confname);
3407                         return -1;
3408                 }
3409                 wpa_s->confanother = os_rel2abs_path(iface->confanother);
3410                 wpa_config_read(wpa_s->confanother, wpa_s->conf);
3411
3412 #ifdef CONFIG_P2P
3413                 wpa_s->conf_p2p_dev = os_rel2abs_path(iface->conf_p2p_dev);
3414                 wpa_config_read(wpa_s->conf_p2p_dev, wpa_s->conf);
3415 #endif /* CONFIG_P2P */
3416
3417                 /*
3418                  * Override ctrl_interface and driver_param if set on command
3419                  * line.
3420                  */
3421                 if (iface->ctrl_interface) {
3422                         os_free(wpa_s->conf->ctrl_interface);
3423                         wpa_s->conf->ctrl_interface =
3424                                 os_strdup(iface->ctrl_interface);
3425                 }
3426
3427                 if (iface->driver_param) {
3428                         os_free(wpa_s->conf->driver_param);
3429                         wpa_s->conf->driver_param =
3430                                 os_strdup(iface->driver_param);
3431                 }
3432
3433                 if (iface->p2p_mgmt && !iface->ctrl_interface) {
3434                         os_free(wpa_s->conf->ctrl_interface);
3435                         wpa_s->conf->ctrl_interface = NULL;
3436                 }
3437         } else
3438                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
3439                                                      iface->driver_param);
3440
3441         if (wpa_s->conf == NULL) {
3442                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
3443                 return -1;
3444         }
3445
3446         if (iface->ifname == NULL) {
3447                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
3448                 return -1;
3449         }
3450         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
3451                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
3452                            iface->ifname);
3453                 return -1;
3454         }
3455         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
3456
3457         if (iface->bridge_ifname) {
3458                 if (os_strlen(iface->bridge_ifname) >=
3459                     sizeof(wpa_s->bridge_ifname)) {
3460                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
3461                                    "name '%s'.", iface->bridge_ifname);
3462                         return -1;
3463                 }
3464                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
3465                            sizeof(wpa_s->bridge_ifname));
3466         }
3467
3468         /* RSNA Supplicant Key Management - INITIALIZE */
3469         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
3470         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
3471
3472         /* Initialize driver interface and register driver event handler before
3473          * L2 receive handler so that association events are processed before
3474          * EAPOL-Key packets if both become available for the same select()
3475          * call. */
3476         if (wpas_init_driver(wpa_s, iface) < 0)
3477                 return -1;
3478
3479         if (wpa_supplicant_init_wpa(wpa_s) < 0)
3480                 return -1;
3481
3482         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
3483                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
3484                           NULL);
3485         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
3486
3487         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
3488             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
3489                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
3490                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3491                         "dot11RSNAConfigPMKLifetime");
3492                 return -1;
3493         }
3494
3495         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
3496             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
3497                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
3498                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3499                         "dot11RSNAConfigPMKReauthThreshold");
3500                 return -1;
3501         }
3502
3503         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
3504             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
3505                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
3506                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
3507                         "dot11RSNAConfigSATimeout");
3508                 return -1;
3509         }
3510
3511         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
3512                                                       &wpa_s->hw.num_modes,
3513                                                       &wpa_s->hw.flags);
3514
3515         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
3516                 wpa_s->drv_capa_known = 1;
3517                 wpa_s->drv_flags = capa.flags;
3518                 wpa_s->drv_enc = capa.enc;
3519                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
3520                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
3521                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
3522                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
3523                 wpa_s->max_match_sets = capa.max_match_sets;
3524                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
3525                 wpa_s->max_stations = capa.max_stations;
3526                 wpa_s->extended_capa = capa.extended_capa;
3527                 wpa_s->extended_capa_mask = capa.extended_capa_mask;
3528                 wpa_s->extended_capa_len = capa.extended_capa_len;
3529                 wpa_s->num_multichan_concurrent =
3530                         capa.num_multichan_concurrent;
3531         }
3532         if (wpa_s->max_remain_on_chan == 0)
3533                 wpa_s->max_remain_on_chan = 1000;
3534
3535         /*
3536          * Only take p2p_mgmt parameters when P2P Device is supported.
3537          * Doing it here as it determines whether l2_packet_init() will be done
3538          * during wpa_supplicant_driver_init().
3539          */
3540         if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
3541                 wpa_s->p2p_mgmt = iface->p2p_mgmt;
3542         else
3543                 iface->p2p_mgmt = 1;
3544
3545         if (wpa_s->num_multichan_concurrent == 0)
3546                 wpa_s->num_multichan_concurrent = 1;
3547
3548         if (wpa_supplicant_driver_init(wpa_s) < 0)
3549                 return -1;
3550
3551 #ifdef CONFIG_TDLS
3552         if ((!iface->p2p_mgmt ||
3553              !(wpa_s->drv_flags &
3554                WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3555             wpa_tdls_init(wpa_s->wpa))
3556                 return -1;
3557 #endif /* CONFIG_TDLS */
3558
3559         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
3560             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
3561                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
3562                 return -1;
3563         }
3564
3565         if (wpas_wps_init(wpa_s))
3566                 return -1;
3567
3568         if (wpa_supplicant_init_eapol(wpa_s) < 0)
3569                 return -1;
3570         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3571
3572         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
3573         if (wpa_s->ctrl_iface == NULL) {
3574                 wpa_printf(MSG_ERROR,
3575                            "Failed to initialize control interface '%s'.\n"
3576                            "You may have another wpa_supplicant process "
3577                            "already running or the file was\n"
3578                            "left by an unclean termination of wpa_supplicant "
3579                            "in which case you will need\n"
3580                            "to manually remove this file before starting "
3581                            "wpa_supplicant again.\n",
3582                            wpa_s->conf->ctrl_interface);
3583                 return -1;
3584         }
3585
3586         wpa_s->gas = gas_query_init(wpa_s);
3587         if (wpa_s->gas == NULL) {
3588                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
3589                 return -1;
3590         }
3591
3592 #ifdef CONFIG_P2P
3593         if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
3594                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
3595                 return -1;
3596         }
3597 #endif /* CONFIG_P2P */
3598
3599         if (wpa_bss_init(wpa_s) < 0)
3600                 return -1;
3601
3602 #ifdef CONFIG_EAP_PROXY
3603 {
3604         size_t len;
3605         wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
3606                                                      &len);
3607         if (wpa_s->mnc_len > 0) {
3608                 wpa_s->imsi[len] = '\0';
3609                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
3610                            wpa_s->imsi, wpa_s->mnc_len);
3611         } else {
3612                 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
3613         }
3614 }
3615 #endif /* CONFIG_EAP_PROXY */
3616
3617         if (pcsc_reader_init(wpa_s) < 0)
3618                 return -1;
3619
3620         if (wpas_init_ext_pw(wpa_s) < 0)
3621                 return -1;
3622
3623         return 0;
3624 }
3625
3626
3627 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
3628                                         int notify, int terminate)
3629 {
3630         wpa_s->disconnected = 1;
3631         if (wpa_s->drv_priv) {
3632                 wpa_supplicant_deauthenticate(wpa_s,
3633                                               WLAN_REASON_DEAUTH_LEAVING);
3634
3635                 wpa_drv_set_countermeasures(wpa_s, 0);
3636                 wpa_clear_keys(wpa_s, NULL);
3637         }
3638
3639         wpa_supplicant_cleanup(wpa_s);
3640
3641 #ifdef CONFIG_P2P
3642         if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
3643                 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
3644                         "the management interface is being removed");
3645                 wpas_p2p_deinit_global(wpa_s->global);
3646         }
3647 #endif /* CONFIG_P2P */
3648
3649         wpas_ctrl_radio_work_flush(wpa_s);
3650         radio_remove_interface(wpa_s);
3651
3652         if (wpa_s->drv_priv)
3653                 wpa_drv_deinit(wpa_s);
3654
3655         if (notify)
3656                 wpas_notify_iface_removed(wpa_s);
3657
3658         if (terminate)
3659                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
3660
3661         if (wpa_s->ctrl_iface) {
3662                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
3663                 wpa_s->ctrl_iface = NULL;
3664         }
3665
3666         if (wpa_s->conf != NULL) {
3667                 wpa_config_free(wpa_s->conf);
3668                 wpa_s->conf = NULL;
3669         }
3670
3671         os_free(wpa_s);
3672 }
3673
3674
3675 /**
3676  * wpa_supplicant_add_iface - Add a new network interface
3677  * @global: Pointer to global data from wpa_supplicant_init()
3678  * @iface: Interface configuration options
3679  * Returns: Pointer to the created interface or %NULL on failure
3680  *
3681  * This function is used to add new network interfaces for %wpa_supplicant.
3682  * This can be called before wpa_supplicant_run() to add interfaces before the
3683  * main event loop has been started. In addition, new interfaces can be added
3684  * dynamically while %wpa_supplicant is already running. This could happen,
3685  * e.g., when a hotplug network adapter is inserted.
3686  */
3687 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
3688                                                  struct wpa_interface *iface)
3689 {
3690         struct wpa_supplicant *wpa_s;
3691         struct wpa_interface t_iface;
3692         struct wpa_ssid *ssid;
3693
3694         if (global == NULL || iface == NULL)
3695                 return NULL;
3696
3697         wpa_s = wpa_supplicant_alloc();
3698         if (wpa_s == NULL)
3699                 return NULL;
3700
3701         wpa_s->global = global;
3702
3703         t_iface = *iface;
3704         if (global->params.override_driver) {
3705                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
3706                            "('%s' -> '%s')",
3707                            iface->driver, global->params.override_driver);
3708                 t_iface.driver = global->params.override_driver;
3709         }
3710         if (global->params.override_ctrl_interface) {
3711                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
3712                            "ctrl_interface ('%s' -> '%s')",
3713                            iface->ctrl_interface,
3714                            global->params.override_ctrl_interface);
3715                 t_iface.ctrl_interface =
3716                         global->params.override_ctrl_interface;
3717         }
3718         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
3719                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
3720                            iface->ifname);
3721                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
3722                 return NULL;
3723         }
3724
3725         /* Notify the control interfaces about new iface */
3726         if (wpas_notify_iface_added(wpa_s)) {
3727                 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
3728                 return NULL;
3729         }
3730
3731         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3732                 wpas_notify_network_added(wpa_s, ssid);
3733
3734         wpa_s->next = global->ifaces;
3735         global->ifaces = wpa_s;
3736
3737         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
3738         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3739
3740         return wpa_s;
3741 }
3742
3743
3744 /**
3745  * wpa_supplicant_remove_iface - Remove a network interface
3746  * @global: Pointer to global data from wpa_supplicant_init()
3747  * @wpa_s: Pointer to the network interface to be removed
3748  * Returns: 0 if interface was removed, -1 if interface was not found
3749  *
3750  * This function can be used to dynamically remove network interfaces from
3751  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
3752  * addition, this function is used to remove all remaining interfaces when
3753  * %wpa_supplicant is terminated.
3754  */
3755 int wpa_supplicant_remove_iface(struct wpa_global *global,
3756                                 struct wpa_supplicant *wpa_s,
3757                                 int terminate)
3758 {
3759         struct wpa_supplicant *prev;
3760
3761         /* Remove interface from the global list of interfaces */
3762         prev = global->ifaces;
3763         if (prev == wpa_s) {
3764                 global->ifaces = wpa_s->next;
3765         } else {
3766                 while (prev && prev->next != wpa_s)
3767                         prev = prev->next;
3768                 if (prev == NULL)
3769                         return -1;
3770                 prev->next = wpa_s->next;
3771         }
3772
3773         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3774
3775         if (global->p2p_group_formation == wpa_s)
3776                 global->p2p_group_formation = NULL;
3777         if (global->p2p_invite_group == wpa_s)
3778                 global->p2p_invite_group = NULL;
3779         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3780
3781         return 0;
3782 }
3783
3784
3785 /**
3786  * wpa_supplicant_get_eap_mode - Get the current EAP mode
3787  * @wpa_s: Pointer to the network interface
3788  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
3789  */
3790 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3791 {
3792         const char *eapol_method;
3793
3794         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3795             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3796                 return "NO-EAP";
3797         }
3798
3799         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3800         if (eapol_method == NULL)
3801                 return "UNKNOWN-EAP";
3802
3803         return eapol_method;
3804 }
3805
3806
3807 /**
3808  * wpa_supplicant_get_iface - Get a new network interface
3809  * @global: Pointer to global data from wpa_supplicant_init()
3810  * @ifname: Interface name
3811  * Returns: Pointer to the interface or %NULL if not found
3812  */
3813 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
3814                                                  const char *ifname)
3815 {
3816         struct wpa_supplicant *wpa_s;
3817
3818         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3819                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3820                         return wpa_s;
3821         }
3822         return NULL;
3823 }
3824
3825
3826 #ifndef CONFIG_NO_WPA_MSG
3827 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
3828 {
3829         struct wpa_supplicant *wpa_s = ctx;
3830         if (wpa_s == NULL)
3831                 return NULL;
3832         return wpa_s->ifname;
3833 }
3834 #endif /* CONFIG_NO_WPA_MSG */
3835
3836
3837 /**
3838  * wpa_supplicant_init - Initialize %wpa_supplicant
3839  * @params: Parameters for %wpa_supplicant
3840  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
3841  *
3842  * This function is used to initialize %wpa_supplicant. After successful
3843  * initialization, the returned data pointer can be used to add and remove
3844  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
3845  */
3846 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
3847 {
3848         struct wpa_global *global;
3849         int ret, i;
3850
3851         if (params == NULL)
3852                 return NULL;
3853
3854 #ifdef CONFIG_DRIVER_NDIS
3855         {
3856                 void driver_ndis_init_ops(void);
3857                 driver_ndis_init_ops();
3858         }
3859 #endif /* CONFIG_DRIVER_NDIS */
3860
3861 #ifndef CONFIG_NO_WPA_MSG
3862         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
3863 #endif /* CONFIG_NO_WPA_MSG */
3864
3865         wpa_debug_open_file(params->wpa_debug_file_path);
3866         if (params->wpa_debug_syslog)
3867                 wpa_debug_open_syslog();
3868         if (params->wpa_debug_tracing) {
3869                 ret = wpa_debug_open_linux_tracing();
3870                 if (ret) {
3871                         wpa_printf(MSG_ERROR,
3872                                    "Failed to enable trace logging");
3873                         return NULL;
3874                 }
3875         }
3876
3877         ret = eap_register_methods();
3878         if (ret) {
3879                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
3880                 if (ret == -2)
3881                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
3882                                    "the same EAP type.");
3883                 return NULL;
3884         }
3885
3886         global = os_zalloc(sizeof(*global));
3887         if (global == NULL)
3888                 return NULL;
3889         dl_list_init(&global->p2p_srv_bonjour);
3890         dl_list_init(&global->p2p_srv_upnp);
3891         global->params.daemonize = params->daemonize;
3892         global->params.wait_for_monitor = params->wait_for_monitor;
3893         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
3894         if (params->pid_file)
3895                 global->params.pid_file = os_strdup(params->pid_file);
3896         if (params->ctrl_interface)
3897                 global->params.ctrl_interface =
3898                         os_strdup(params->ctrl_interface);
3899         if (params->ctrl_interface_group)
3900                 global->params.ctrl_interface_group =
3901                         os_strdup(params->ctrl_interface_group);
3902         if (params->override_driver)
3903                 global->params.override_driver =
3904                         os_strdup(params->override_driver);
3905         if (params->override_ctrl_interface)
3906                 global->params.override_ctrl_interface =
3907                         os_strdup(params->override_ctrl_interface);
3908         wpa_debug_level = global->params.wpa_debug_level =
3909                 params->wpa_debug_level;
3910         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
3911                 params->wpa_debug_show_keys;
3912         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
3913                 params->wpa_debug_timestamp;
3914
3915         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
3916
3917         if (eloop_init()) {
3918                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
3919                 wpa_supplicant_deinit(global);
3920                 return NULL;
3921         }
3922
3923         random_init(params->entropy_file);
3924
3925         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
3926         if (global->ctrl_iface == NULL) {
3927                 wpa_supplicant_deinit(global);
3928                 return NULL;
3929         }
3930
3931         if (wpas_notify_supplicant_initialized(global)) {
3932                 wpa_supplicant_deinit(global);
3933                 return NULL;
3934         }
3935
3936         for (i = 0; wpa_drivers[i]; i++)
3937                 global->drv_count++;
3938         if (global->drv_count == 0) {
3939                 wpa_printf(MSG_ERROR, "No drivers enabled");
3940                 wpa_supplicant_deinit(global);
3941                 return NULL;
3942         }
3943         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
3944         if (global->drv_priv == NULL) {
3945                 wpa_supplicant_deinit(global);
3946                 return NULL;
3947         }
3948
3949 #ifdef CONFIG_WIFI_DISPLAY
3950         if (wifi_display_init(global) < 0) {
3951                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
3952                 wpa_supplicant_deinit(global);
3953                 return NULL;
3954         }
3955 #endif /* CONFIG_WIFI_DISPLAY */
3956
3957         return global;
3958 }
3959
3960
3961 /**
3962  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
3963  * @global: Pointer to global data from wpa_supplicant_init()
3964  * Returns: 0 after successful event loop run, -1 on failure
3965  *
3966  * This function starts the main event loop and continues running as long as
3967  * there are any remaining events. In most cases, this function is running as
3968  * long as the %wpa_supplicant process in still in use.
3969  */
3970 int wpa_supplicant_run(struct wpa_global *global)
3971 {
3972         struct wpa_supplicant *wpa_s;
3973
3974         if (global->params.daemonize &&
3975             wpa_supplicant_daemon(global->params.pid_file))
3976                 return -1;
3977
3978         if (global->params.wait_for_monitor) {
3979                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
3980                         if (wpa_s->ctrl_iface)
3981                                 wpa_supplicant_ctrl_iface_wait(
3982                                         wpa_s->ctrl_iface);
3983         }
3984
3985         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
3986         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
3987
3988         eloop_run();
3989
3990         return 0;
3991 }
3992
3993
3994 /**
3995  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
3996  * @global: Pointer to global data from wpa_supplicant_init()
3997  *
3998  * This function is called to deinitialize %wpa_supplicant and to free all
3999  * allocated resources. Remaining network interfaces will also be removed.
4000  */
4001 void wpa_supplicant_deinit(struct wpa_global *global)
4002 {
4003         int i;
4004
4005         if (global == NULL)
4006                 return;
4007
4008 #ifdef CONFIG_WIFI_DISPLAY
4009         wifi_display_deinit(global);
4010 #endif /* CONFIG_WIFI_DISPLAY */
4011
4012         while (global->ifaces)
4013                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
4014
4015         if (global->ctrl_iface)
4016                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
4017
4018         wpas_notify_supplicant_deinitialized(global);
4019
4020         eap_peer_unregister_methods();
4021 #ifdef CONFIG_AP
4022         eap_server_unregister_methods();
4023 #endif /* CONFIG_AP */
4024
4025         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
4026                 if (!global->drv_priv[i])
4027                         continue;
4028                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
4029         }
4030         os_free(global->drv_priv);
4031
4032         random_deinit();
4033
4034         eloop_destroy();
4035
4036         if (global->params.pid_file) {
4037                 os_daemonize_terminate(global->params.pid_file);
4038                 os_free(global->params.pid_file);
4039         }
4040         os_free(global->params.ctrl_interface);
4041         os_free(global->params.ctrl_interface_group);
4042         os_free(global->params.override_driver);
4043         os_free(global->params.override_ctrl_interface);
4044
4045         os_free(global->p2p_disallow_freq.range);
4046         os_free(global->p2p_go_avoid_freq.range);
4047         os_free(global->add_psk);
4048
4049         os_free(global);
4050         wpa_debug_close_syslog();
4051         wpa_debug_close_file();
4052         wpa_debug_close_linux_tracing();
4053 }
4054
4055
4056 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
4057 {
4058         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
4059             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
4060                 char country[3];
4061                 country[0] = wpa_s->conf->country[0];
4062                 country[1] = wpa_s->conf->country[1];
4063                 country[2] = '\0';
4064                 if (wpa_drv_set_country(wpa_s, country) < 0) {
4065                         wpa_printf(MSG_ERROR, "Failed to set country code "
4066                                    "'%s'", country);
4067                 }
4068         }
4069
4070         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
4071                 wpas_init_ext_pw(wpa_s);
4072
4073 #ifdef CONFIG_WPS
4074         wpas_wps_update_config(wpa_s);
4075 #endif /* CONFIG_WPS */
4076
4077 #ifdef CONFIG_P2P
4078         wpas_p2p_update_config(wpa_s);
4079 #endif /* CONFIG_P2P */
4080
4081         wpa_s->conf->changed_parameters = 0;
4082 }
4083
4084
4085 static void add_freq(int *freqs, int *num_freqs, int freq)
4086 {
4087         int i;
4088
4089         for (i = 0; i < *num_freqs; i++) {
4090                 if (freqs[i] == freq)
4091                         return;
4092         }
4093
4094         freqs[*num_freqs] = freq;
4095         (*num_freqs)++;
4096 }
4097
4098
4099 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
4100 {
4101         struct wpa_bss *bss, *cbss;
4102         const int max_freqs = 10;
4103         int *freqs;
4104         int num_freqs = 0;
4105
4106         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
4107         if (freqs == NULL)
4108                 return NULL;
4109
4110         cbss = wpa_s->current_bss;
4111
4112         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
4113                 if (bss == cbss)
4114                         continue;
4115                 if (bss->ssid_len == cbss->ssid_len &&
4116                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
4117                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
4118                         add_freq(freqs, &num_freqs, bss->freq);
4119                         if (num_freqs == max_freqs)
4120                                 break;
4121                 }
4122         }
4123
4124         if (num_freqs == 0) {
4125                 os_free(freqs);
4126                 freqs = NULL;
4127         }
4128
4129         return freqs;
4130 }
4131
4132
4133 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
4134 {
4135         int timeout;
4136         int count;
4137         int *freqs = NULL;
4138
4139         wpas_connect_work_done(wpa_s);
4140
4141         /*
4142          * Remove possible authentication timeout since the connection failed.
4143          */
4144         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4145
4146         if (wpa_s->disconnected) {
4147                 /*
4148                  * There is no point in blacklisting the AP if this event is
4149                  * generated based on local request to disconnect.
4150                  */
4151                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
4152                         "indication since interface has been put into "
4153                         "disconnected state");
4154                 return;
4155         }
4156
4157         /*
4158          * Add the failed BSSID into the blacklist and speed up next scan
4159          * attempt if there could be other APs that could accept association.
4160          * The current blacklist count indicates how many times we have tried
4161          * connecting to this AP and multiple attempts mean that other APs are
4162          * either not available or has already been tried, so that we can start
4163          * increasing the delay here to avoid constant scanning.
4164          */
4165         count = wpa_blacklist_add(wpa_s, bssid);
4166         if (count == 1 && wpa_s->current_bss) {
4167                 /*
4168                  * This BSS was not in the blacklist before. If there is
4169                  * another BSS available for the same ESS, we should try that
4170                  * next. Otherwise, we may as well try this one once more
4171                  * before allowing other, likely worse, ESSes to be considered.
4172                  */
4173                 freqs = get_bss_freqs_in_ess(wpa_s);
4174                 if (freqs) {
4175                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
4176                                 "has been seen; try it next");
4177                         wpa_blacklist_add(wpa_s, bssid);
4178                         /*
4179                          * On the next scan, go through only the known channels
4180                          * used in this ESS based on previous scans to speed up
4181                          * common load balancing use case.
4182                          */
4183                         os_free(wpa_s->next_scan_freqs);
4184                         wpa_s->next_scan_freqs = freqs;
4185                 }
4186         }
4187
4188         /*
4189          * Add previous failure count in case the temporary blacklist was
4190          * cleared due to no other BSSes being available.
4191          */
4192         count += wpa_s->extra_blacklist_count;
4193
4194         if (count > 3 && wpa_s->current_ssid) {
4195                 wpa_printf(MSG_DEBUG, "Continuous association failures - "
4196                            "consider temporary network disabling");
4197                 wpas_auth_failed(wpa_s);
4198         }
4199
4200         switch (count) {
4201         case 1:
4202                 timeout = 100;
4203                 break;
4204         case 2:
4205                 timeout = 500;
4206                 break;
4207         case 3:
4208                 timeout = 1000;
4209                 break;
4210         case 4:
4211                 timeout = 5000;
4212                 break;
4213         default:
4214                 timeout = 10000;
4215                 break;
4216         }
4217
4218         wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
4219                 "ms", count, timeout);
4220
4221         /*
4222          * TODO: if more than one possible AP is available in scan results,
4223          * could try the other ones before requesting a new scan.
4224          */
4225         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
4226                                 1000 * (timeout % 1000));
4227 }
4228
4229
4230 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
4231 {
4232         return wpa_s->conf->ap_scan == 2 ||
4233                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
4234 }
4235
4236
4237 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
4238 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
4239                                               struct wpa_ssid *ssid,
4240                                               const char *field,
4241                                               const char *value)
4242 {
4243 #ifdef IEEE8021X_EAPOL
4244         struct eap_peer_config *eap = &ssid->eap;
4245
4246         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
4247         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
4248                               (const u8 *) value, os_strlen(value));
4249
4250         switch (wpa_supplicant_ctrl_req_from_string(field)) {
4251         case WPA_CTRL_REQ_EAP_IDENTITY:
4252                 os_free(eap->identity);
4253                 eap->identity = (u8 *) os_strdup(value);
4254                 eap->identity_len = os_strlen(value);
4255                 eap->pending_req_identity = 0;
4256                 if (ssid == wpa_s->current_ssid)
4257                         wpa_s->reassociate = 1;
4258                 break;
4259         case WPA_CTRL_REQ_EAP_PASSWORD:
4260                 os_free(eap->password);
4261                 eap->password = (u8 *) os_strdup(value);
4262                 eap->password_len = os_strlen(value);
4263                 eap->pending_req_password = 0;
4264                 if (ssid == wpa_s->current_ssid)
4265                         wpa_s->reassociate = 1;
4266                 break;
4267         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
4268                 os_free(eap->new_password);
4269                 eap->new_password = (u8 *) os_strdup(value);
4270                 eap->new_password_len = os_strlen(value);
4271                 eap->pending_req_new_password = 0;
4272                 if (ssid == wpa_s->current_ssid)
4273                         wpa_s->reassociate = 1;
4274                 break;
4275         case WPA_CTRL_REQ_EAP_PIN:
4276                 os_free(eap->pin);
4277                 eap->pin = os_strdup(value);
4278                 eap->pending_req_pin = 0;
4279                 if (ssid == wpa_s->current_ssid)
4280                         wpa_s->reassociate = 1;
4281                 break;
4282         case WPA_CTRL_REQ_EAP_OTP:
4283                 os_free(eap->otp);
4284                 eap->otp = (u8 *) os_strdup(value);
4285                 eap->otp_len = os_strlen(value);
4286                 os_free(eap->pending_req_otp);
4287                 eap->pending_req_otp = NULL;
4288                 eap->pending_req_otp_len = 0;
4289                 break;
4290         case WPA_CTRL_REQ_EAP_PASSPHRASE:
4291                 os_free(eap->private_key_passwd);
4292                 eap->private_key_passwd = (u8 *) os_strdup(value);
4293                 eap->pending_req_passphrase = 0;
4294                 if (ssid == wpa_s->current_ssid)
4295                         wpa_s->reassociate = 1;
4296                 break;
4297         case WPA_CTRL_REQ_SIM:
4298                 os_free(eap->external_sim_resp);
4299                 eap->external_sim_resp = os_strdup(value);
4300                 break;
4301         default:
4302                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
4303                 return -1;
4304         }
4305
4306         return 0;
4307 #else /* IEEE8021X_EAPOL */
4308         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
4309         return -1;
4310 #endif /* IEEE8021X_EAPOL */
4311 }
4312 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
4313
4314
4315 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
4316 {
4317         int i;
4318         unsigned int drv_enc;
4319
4320         if (ssid == NULL)
4321                 return 1;
4322
4323         if (ssid->disabled)
4324                 return 1;
4325
4326         if (wpa_s && wpa_s->drv_capa_known)
4327                 drv_enc = wpa_s->drv_enc;
4328         else
4329                 drv_enc = (unsigned int) -1;
4330
4331         for (i = 0; i < NUM_WEP_KEYS; i++) {
4332                 size_t len = ssid->wep_key_len[i];
4333                 if (len == 0)
4334                         continue;
4335                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
4336                         continue;
4337                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
4338                         continue;
4339                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
4340                         continue;
4341                 return 1; /* invalid WEP key */
4342         }
4343
4344         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
4345             !ssid->ext_psk)
4346                 return 1;
4347
4348         return 0;
4349 }
4350
4351
4352 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
4353 {
4354         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
4355                 return 1;
4356         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
4357                 return 0;
4358         return -1;
4359 }
4360
4361
4362 void wpas_auth_failed(struct wpa_supplicant *wpa_s)
4363 {
4364         struct wpa_ssid *ssid = wpa_s->current_ssid;
4365         int dur;
4366         struct os_reltime now;
4367
4368         if (ssid == NULL) {
4369                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
4370                            "SSID block");
4371                 return;
4372         }
4373
4374         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
4375                 return;
4376
4377         ssid->auth_failures++;
4378
4379 #ifdef CONFIG_P2P
4380         if (ssid->p2p_group &&
4381             (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
4382                 /*
4383                  * Skip the wait time since there is a short timeout on the
4384                  * connection to a P2P group.
4385                  */
4386                 return;
4387         }
4388 #endif /* CONFIG_P2P */
4389
4390         if (ssid->auth_failures > 50)
4391                 dur = 300;
4392         else if (ssid->auth_failures > 10)
4393                 dur = 120;
4394         else if (ssid->auth_failures > 5)
4395                 dur = 90;
4396         else if (ssid->auth_failures > 3)
4397                 dur = 60;
4398         else if (ssid->auth_failures > 2)
4399                 dur = 30;
4400         else if (ssid->auth_failures > 1)
4401                 dur = 20;
4402         else
4403                 dur = 10;
4404
4405         if (ssid->auth_failures > 1 &&
4406             wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
4407                 dur += os_random() % (ssid->auth_failures * 10);
4408
4409         os_get_reltime(&now);
4410         if (now.sec + dur <= ssid->disabled_until.sec)
4411                 return;
4412
4413         ssid->disabled_until.sec = now.sec + dur;
4414
4415         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
4416                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d",
4417                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
4418                 ssid->auth_failures, dur);
4419 }
4420
4421
4422 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
4423                               struct wpa_ssid *ssid, int clear_failures)
4424 {
4425         if (ssid == NULL)
4426                 return;
4427
4428         if (ssid->disabled_until.sec) {
4429                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
4430                         "id=%d ssid=\"%s\"",
4431                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
4432         }
4433         ssid->disabled_until.sec = 0;
4434         ssid->disabled_until.usec = 0;
4435         if (clear_failures)
4436                 ssid->auth_failures = 0;
4437 }
4438
4439
4440 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
4441 {
4442         size_t i;
4443
4444         if (wpa_s->disallow_aps_bssid == NULL)
4445                 return 0;
4446
4447         for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
4448                 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
4449                               bssid, ETH_ALEN) == 0)
4450                         return 1;
4451         }
4452
4453         return 0;
4454 }
4455
4456
4457 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
4458                     size_t ssid_len)
4459 {
4460         size_t i;
4461
4462         if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
4463                 return 0;
4464
4465         for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
4466                 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
4467                 if (ssid_len == s->ssid_len &&
4468                     os_memcmp(ssid, s->ssid, ssid_len) == 0)
4469                         return 1;
4470         }
4471
4472         return 0;
4473 }
4474
4475
4476 /**
4477  * wpas_request_connection - Request a new connection
4478  * @wpa_s: Pointer to the network interface
4479  *
4480  * This function is used to request a new connection to be found. It will mark
4481  * the interface to allow reassociation and request a new scan to find a
4482  * suitable network to connect to.
4483  */
4484 void wpas_request_connection(struct wpa_supplicant *wpa_s)
4485 {
4486         wpa_s->normal_scans = 0;
4487         wpa_supplicant_reinit_autoscan(wpa_s);
4488         wpa_s->extra_blacklist_count = 0;
4489         wpa_s->disconnected = 0;
4490         wpa_s->reassociate = 1;
4491
4492         if (wpa_supplicant_fast_associate(wpa_s) != 1)
4493                 wpa_supplicant_req_scan(wpa_s, 0, 0);
4494 }
4495
4496
4497 void dump_freq_array(struct wpa_supplicant *wpa_s, const char *title,
4498                      int *freq_array, unsigned int len)
4499 {
4500         unsigned int i;
4501
4502         wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
4503                 len, title);
4504         for (i = 0; i < len; i++)
4505                 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d", i, freq_array[i]);
4506 }
4507
4508
4509 /*
4510  * Find the operating frequencies of any of the virtual interfaces that
4511  * are using the same radio as the current interface.
4512  */
4513 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
4514                            int *freq_array, unsigned int len)
4515 {
4516         struct wpa_supplicant *ifs;
4517         u8 bssid[ETH_ALEN];
4518         int freq;
4519         unsigned int idx = 0, i;
4520
4521         wpa_dbg(wpa_s, MSG_DEBUG,
4522                 "Determining shared radio frequencies (max len %u)", len);
4523         os_memset(freq_array, 0, sizeof(int) * len);
4524
4525         /* First add the frequency of the local interface */
4526         if (wpa_s->current_ssid != NULL && wpa_s->assoc_freq != 0) {
4527                 if (wpa_s->current_ssid->mode == WPAS_MODE_AP ||
4528                     wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)
4529                         freq_array[idx++] = wpa_s->current_ssid->frequency;
4530                 else if (wpa_drv_get_bssid(wpa_s, bssid) == 0)
4531                         freq_array[idx++] = wpa_s->assoc_freq;
4532         }
4533
4534         /* If get_radio_name is not supported, use only the local freq */
4535         if (!wpa_driver_get_radio_name(wpa_s)) {
4536                 freq = wpa_drv_shared_freq(wpa_s);
4537                 if (freq > 0 && idx < len &&
4538                     (idx == 0 || freq_array[0] != freq))
4539                         freq_array[idx++] = freq;
4540                 dump_freq_array(wpa_s, "No get_radio_name", freq_array, idx);
4541                 return idx;
4542         }
4543
4544         dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
4545                          radio_list) {
4546                 if (wpa_s == ifs)
4547                         continue;
4548
4549                 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
4550                         continue;
4551
4552                 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
4553                     ifs->current_ssid->mode == WPAS_MODE_P2P_GO)
4554                         freq = ifs->current_ssid->frequency;
4555                 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
4556                         freq = ifs->assoc_freq;
4557                 else
4558                         continue;
4559
4560                 /* Hold only distinct freqs */
4561                 for (i = 0; i < idx; i++)
4562                         if (freq_array[i] == freq)
4563                                 break;
4564
4565                 if (i == idx)
4566                         freq_array[idx++] = freq;
4567         }
4568
4569         dump_freq_array(wpa_s, "completed iteration", freq_array, idx);
4570         return idx;
4571 }