wpa_supplicant/wpa_supplicant.c

   1 /*
   2  * WPA Supplicant
   3  * Copyright (c) 2003-2012, 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_server/eap_methods.h"
  21 #include "rsn_supp/wpa.h"
  22 #include "eloop.h"
  23 #include "config.h"
  24 #include "utils/ext_password.h"
  25 #include "l2_packet/l2_packet.h"
  26 #include "wpa_supplicant_i.h"
  27 #include "driver_i.h"
  28 #include "ctrl_iface.h"
  29 #include "pcsc_funcs.h"
  30 #include "common/version.h"
  31 #include "rsn_supp/preauth.h"
  32 #include "rsn_supp/pmksa_cache.h"
  33 #include "common/wpa_ctrl.h"
  34 #include "common/ieee802_11_defs.h"
  35 #include "p2p/p2p.h"
  36 #include "blacklist.h"
  37 #include "wpas_glue.h"
  38 #include "wps_supplicant.h"
  39 #include "ibss_rsn.h"
  40 #include "sme.h"
  41 #include "gas_query.h"
  42 #include "ap.h"
  43 #include "p2p_supplicant.h"
  44 #include "wifi_display.h"
  45 #include "notify.h"
  46 #include "bgscan.h"
  47 #include "autoscan.h"
  48 #include "bss.h"
  49 #include "scan.h"
  50 #include "offchannel.h"
  51 #include "hs20_supplicant.h"
  52
  53 const char *wpa_supplicant_version =
  54 "wpa_supplicant v" VERSION_STR "\n"
  55 "Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi> and contributors";
  56
  57 const char *wpa_supplicant_license =
  58 "This software may be distributed under the terms of the BSD license.\n"
  59 "See README for more details.\n"
  60 #ifdef EAP_TLS_OPENSSL
  61 "\nThis product includes software developed by the OpenSSL Project\n"
  62 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
  63 #endif /* EAP_TLS_OPENSSL */
  64 ;
  65
  66 #ifndef CONFIG_NO_STDOUT_DEBUG
  67 /* Long text divided into parts in order to fit in C89 strings size limits. */
  68 const char *wpa_supplicant_full_license1 =
  69 "";
  70 const char *wpa_supplicant_full_license2 =
  71 "This software may be distributed under the terms of the BSD license.\n"
  72 "\n"
  73 "Redistribution and use in source and binary forms, with or without\n"
  74 "modification, are permitted provided that the following conditions are\n"
  75 "met:\n"
  76 "\n";
  77 const char *wpa_supplicant_full_license3 =
  78 "1. Redistributions of source code must retain the above copyright\n"
  79 "   notice, this list of conditions and the following disclaimer.\n"
  80 "\n"
  81 "2. Redistributions in binary form must reproduce the above copyright\n"
  82 "   notice, this list of conditions and the following disclaimer in the\n"
  83 "   documentation and/or other materials provided with the distribution.\n"
  84 "\n";
  85 const char *wpa_supplicant_full_license4 =
  86 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
  87 "   names of its contributors may be used to endorse or promote products\n"
  88 "   derived from this software without specific prior written permission.\n"
  89 "\n"
  90 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
  91 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
  92 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
  93 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
  94 const char *wpa_supplicant_full_license5 =
  95 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
  96 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
  97 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
  98 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
  99 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
 100 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
 101 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
 102 "\n";
 103 #endif /* CONFIG_NO_STDOUT_DEBUG */
 104
 105 extern int wpa_debug_level;
 106 extern int wpa_debug_show_keys;
 107 extern int wpa_debug_timestamp;
 108 extern struct wpa_driver_ops *wpa_drivers[];
 109
 110 /* Configure default/group WEP keys for static WEP */
 111 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
 112 {
 113         int i, set = 0;
 114
 115         for (i = 0; i < NUM_WEP_KEYS; i++) {
 116                 if (ssid->wep_key_len[i] == 0)
 117                         continue;
 118
 119                 set = 1;
 120                 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
 121                                 i, i == ssid->wep_tx_keyidx, NULL, 0,
 122                                 ssid->wep_key[i], ssid->wep_key_len[i]);
 123         }
 124
 125         return set;
 126 }
 127
 128
 129 static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
 130                                            struct wpa_ssid *ssid)
 131 {
 132         u8 key[32];
 133         size_t keylen;
 134         enum wpa_alg alg;
 135         u8 seq[6] = { 0 };
 136
 137         /* IBSS/WPA-None uses only one key (Group) for both receiving and
 138          * sending unicast and multicast packets. */
 139
 140         if (ssid->mode != WPAS_MODE_IBSS) {
 141                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
 142                         "IBSS/ad-hoc) for WPA-None", ssid->mode);
 143                 return -1;
 144         }
 145
 146         if (!ssid->psk_set) {
 147                 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
 148                         "WPA-None");
 149                 return -1;
 150         }
 151
 152         switch (wpa_s->group_cipher) {
 153         case WPA_CIPHER_CCMP:
 154                 os_memcpy(key, ssid->psk, 16);
 155                 keylen = 16;
 156                 alg = WPA_ALG_CCMP;
 157                 break;
 158         case WPA_CIPHER_GCMP:
 159                 os_memcpy(key, ssid->psk, 16);
 160                 keylen = 16;
 161                 alg = WPA_ALG_GCMP;
 162                 break;
 163         case WPA_CIPHER_TKIP:
 164                 /* WPA-None uses the same Michael MIC key for both TX and RX */
 165                 os_memcpy(key, ssid->psk, 16 + 8);
 166                 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
 167                 keylen = 32;
 168                 alg = WPA_ALG_TKIP;
 169                 break;
 170         default:
 171                 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
 172                         "WPA-None", wpa_s->group_cipher);
 173                 return -1;
 174         }
 175
 176         /* TODO: should actually remember the previously used seq#, both for TX
 177          * and RX from each STA.. */
 178
 179         return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
 180 }
 181
 182
 183 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 184 {
 185         struct wpa_supplicant *wpa_s = eloop_ctx;
 186         const u8 *bssid = wpa_s->bssid;
 187         if (is_zero_ether_addr(bssid))
 188                 bssid = wpa_s->pending_bssid;
 189         wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
 190                 MAC2STR(bssid));
 191         wpa_blacklist_add(wpa_s, bssid);
 192         wpa_sm_notify_disassoc(wpa_s->wpa);
 193         wpa_supplicant_disassociate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
 194         wpa_s->reassociate = 1;
 195
 196         /*
 197          * If we timed out, the AP or the local radio may be busy.
 198          * So, wait a second until scanning again.
 199          */
 200         wpa_supplicant_req_scan(wpa_s, 1, 0);
 201
 202 #ifdef CONFIG_P2P
 203         if (wpa_s->global->p2p_cb_on_scan_complete && !wpa_s->global->p2p_disabled &&
 204             wpa_s->global->p2p != NULL) {
 205                 wpa_s->global->p2p_cb_on_scan_complete = 0;
 206                 if (p2p_other_scan_completed(wpa_s->global->p2p) == 1) {
 207                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Pending P2P operation "
 208                                 "continued after timed out authentication");
 209                 }
 210         }
 211 #endif /* CONFIG_P2P */
 212 }
 213
 214
 215 /**
 216  * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
 217  * @wpa_s: Pointer to wpa_supplicant data
 218  * @sec: Number of seconds after which to time out authentication
 219  * @usec: Number of microseconds after which to time out authentication
 220  *
 221  * This function is used to schedule a timeout for the current authentication
 222  * attempt.
 223  */
 224 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 225                                      int sec, int usec)
 226 {
 227         if (wpa_s->conf && wpa_s->conf->ap_scan == 0 &&
 228             (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 229                 return;
 230
 231         wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
 232                 "%d usec", sec, usec);
 233         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 234         eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
 235 }
 236
 237
 238 /**
 239  * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
 240  * @wpa_s: Pointer to wpa_supplicant data
 241  *
 242  * This function is used to cancel authentication timeout scheduled with
 243  * wpa_supplicant_req_auth_timeout() and it is called when authentication has
 244  * been completed.
 245  */
 246 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 247 {
 248         wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
 249         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 250         wpa_blacklist_del(wpa_s, wpa_s->bssid);
 251 }
 252
 253
 254 /**
 255  * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
 256  * @wpa_s: Pointer to wpa_supplicant data
 257  *
 258  * This function is used to configure EAPOL state machine based on the selected
 259  * authentication mode.
 260  */
 261 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
 262 {
 263 #ifdef IEEE8021X_EAPOL
 264         struct eapol_config eapol_conf;
 265         struct wpa_ssid *ssid = wpa_s->current_ssid;
 266
 267 #ifdef CONFIG_IBSS_RSN
 268         if (ssid->mode == WPAS_MODE_IBSS &&
 269             wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
 270             wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
 271                 /*
 272                  * RSN IBSS authentication is per-STA and we can disable the
 273                  * per-BSSID EAPOL authentication.
 274                  */
 275                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 276                 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
 277                 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 278                 return;
 279         }
 280 #endif /* CONFIG_IBSS_RSN */
 281
 282         eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 283         eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
 284
 285         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
 286             wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
 287                 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
 288         else
 289                 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
 290
 291         os_memset(&eapol_conf, 0, sizeof(eapol_conf));
 292         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
 293                 eapol_conf.accept_802_1x_keys = 1;
 294                 eapol_conf.required_keys = 0;
 295                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
 296                         eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
 297                 }
 298                 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
 299                         eapol_conf.required_keys |=
 300                                 EAPOL_REQUIRE_KEY_BROADCAST;
 301                 }
 302
 303                 if (wpa_s->conf && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
 304                         eapol_conf.required_keys = 0;
 305         }
 306         if (wpa_s->conf)
 307                 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
 308         eapol_conf.workaround = ssid->eap_workaround;
 309         eapol_conf.eap_disabled =
 310                 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
 311                 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
 312                 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
 313         eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
 314 #endif /* IEEE8021X_EAPOL */
 315 }
 316
 317
 318 /**
 319  * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
 320  * @wpa_s: Pointer to wpa_supplicant data
 321  * @ssid: Configuration data for the network
 322  *
 323  * This function is used to configure WPA state machine and related parameters
 324  * to a mode where WPA is not enabled. This is called as part of the
 325  * authentication configuration when the selected network does not use WPA.
 326  */
 327 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
 328                                        struct wpa_ssid *ssid)
 329 {
 330         int i;
 331
 332         if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
 333                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
 334         else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
 335                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
 336         else
 337                 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
 338         wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
 339         wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
 340         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
 341         wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 342         wpa_s->group_cipher = WPA_CIPHER_NONE;
 343         wpa_s->mgmt_group_cipher = 0;
 344
 345         for (i = 0; i < NUM_WEP_KEYS; i++) {
 346                 if (ssid->wep_key_len[i] > 5) {
 347                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
 348                         wpa_s->group_cipher = WPA_CIPHER_WEP104;
 349                         break;
 350                 } else if (ssid->wep_key_len[i] > 0) {
 351                         wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
 352                         wpa_s->group_cipher = WPA_CIPHER_WEP40;
 353                         break;
 354                 }
 355         }
 356
 357         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
 358         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
 359         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
 360                          wpa_s->pairwise_cipher);
 361         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
 362 #ifdef CONFIG_IEEE80211W
 363         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
 364                          wpa_s->mgmt_group_cipher);
 365 #endif /* CONFIG_IEEE80211W */
 366
 367         pmksa_cache_clear_current(wpa_s->wpa);
 368 }
 369
 370
 371 void free_hw_features(struct wpa_supplicant *wpa_s)
 372 {
 373         int i;
 374         if (wpa_s->hw.modes == NULL)
 375                 return;
 376
 377         for (i = 0; i < wpa_s->hw.num_modes; i++) {
 378                 os_free(wpa_s->hw.modes[i].channels);
 379                 os_free(wpa_s->hw.modes[i].rates);
 380         }
 381
 382         os_free(wpa_s->hw.modes);
 383         wpa_s->hw.modes = NULL;
 384 }
 385
 386
 387 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 388 {
 389         bgscan_deinit(wpa_s);
 390         autoscan_deinit(wpa_s);
 391         scard_deinit(wpa_s->scard);
 392         wpa_s->scard = NULL;
 393         wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
 394         eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
 395         l2_packet_deinit(wpa_s->l2);
 396         wpa_s->l2 = NULL;
 397         if (wpa_s->l2_br) {
 398                 l2_packet_deinit(wpa_s->l2_br);
 399                 wpa_s->l2_br = NULL;
 400         }
 401
 402         if (wpa_s->conf != NULL) {
 403                 struct wpa_ssid *ssid;
 404                 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
 405                         wpas_notify_network_removed(wpa_s, ssid);
 406         }
 407
 408         os_free(wpa_s->confname);
 409         wpa_s->confname = NULL;
 410
 411         wpa_sm_set_eapol(wpa_s->wpa, NULL);
 412         eapol_sm_deinit(wpa_s->eapol);
 413         wpa_s->eapol = NULL;
 414
 415         rsn_preauth_deinit(wpa_s->wpa);
 416
 417 #ifdef CONFIG_TDLS
 418         wpa_tdls_deinit(wpa_s->wpa);
 419 #endif /* CONFIG_TDLS */
 420
 421         pmksa_candidate_free(wpa_s->wpa);
 422         wpa_sm_deinit(wpa_s->wpa);
 423         wpa_s->wpa = NULL;
 424         wpa_blacklist_clear(wpa_s);
 425
 426         wpa_bss_deinit(wpa_s);
 427
 428         wpa_supplicant_cancel_scan(wpa_s);
 429         wpa_supplicant_cancel_auth_timeout(wpa_s);
 430         eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
 431 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
 432         eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
 433                              wpa_s, NULL);
 434 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
 435
 436         wpas_wps_deinit(wpa_s);
 437
 438         wpabuf_free(wpa_s->pending_eapol_rx);
 439         wpa_s->pending_eapol_rx = NULL;
 440
 441 #ifdef CONFIG_IBSS_RSN
 442         ibss_rsn_deinit(wpa_s->ibss_rsn);
 443         wpa_s->ibss_rsn = NULL;
 444 #endif /* CONFIG_IBSS_RSN */
 445
 446         sme_deinit(wpa_s);
 447
 448 #ifdef CONFIG_AP
 449         wpa_supplicant_ap_deinit(wpa_s);
 450 #endif /* CONFIG_AP */
 451
 452 #ifdef CONFIG_P2P
 453         wpas_p2p_deinit(wpa_s);
 454 #endif /* CONFIG_P2P */
 455
 456 #ifdef CONFIG_OFFCHANNEL
 457         offchannel_deinit(wpa_s);
 458 #endif /* CONFIG_OFFCHANNEL */
 459
 460         wpa_supplicant_cancel_sched_scan(wpa_s);
 461
 462         os_free(wpa_s->next_scan_freqs);
 463         wpa_s->next_scan_freqs = NULL;
 464
 465         gas_query_deinit(wpa_s->gas);
 466         wpa_s->gas = NULL;
 467
 468         free_hw_features(wpa_s);
 469
 470         os_free(wpa_s->bssid_filter);
 471         wpa_s->bssid_filter = NULL;
 472
 473         wnm_bss_keep_alive_deinit(wpa_s);
 474
 475         ext_password_deinit(wpa_s->ext_pw);
 476         wpa_s->ext_pw = NULL;
 477
 478         wpabuf_free(wpa_s->last_gas_resp);
 479
 480         os_free(wpa_s->last_scan_res);
 481         wpa_s->last_scan_res = NULL;
 482 }
 483
 484
 485 /**
 486  * wpa_clear_keys - Clear keys configured for the driver
 487  * @wpa_s: Pointer to wpa_supplicant data
 488  * @addr: Previously used BSSID or %NULL if not available
 489  *
 490  * This function clears the encryption keys that has been previously configured
 491  * for the driver.
 492  */
 493 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
 494 {
 495         if (wpa_s->keys_cleared) {
 496                 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
 497                  * timing issues with keys being cleared just before new keys
 498                  * are set or just after association or something similar. This
 499                  * shows up in group key handshake failing often because of the
 500                  * client not receiving the first encrypted packets correctly.
 501                  * Skipping some of the extra key clearing steps seems to help
 502                  * in completing group key handshake more reliably. */
 503                 wpa_dbg(wpa_s, MSG_DEBUG, "No keys have been configured - "
 504                         "skip key clearing");
 505                 return;
 506         }
 507
 508         /* MLME-DELETEKEYS.request */
 509         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL, 0);
 510         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL, 0);
 511         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL, 0);
 512         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL, 0);
 513 #ifdef CONFIG_IEEE80211W
 514         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL, 0);
 515         wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL, 0);
 516 #endif /* CONFIG_IEEE80211W */
 517         if (addr) {
 518                 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
 519                                 0);
 520                 /* MLME-SETPROTECTION.request(None) */
 521                 wpa_drv_mlme_setprotection(
 522                         wpa_s, addr,
 523                         MLME_SETPROTECTION_PROTECT_TYPE_NONE,
 524                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 525         }
 526         wpa_s->keys_cleared = 1;
 527 }
 528
 529
 530 /**
 531  * wpa_supplicant_state_txt - Get the connection state name as a text string
 532  * @state: State (wpa_state; WPA_*)
 533  * Returns: The state name as a printable text string
 534  */
 535 const char * wpa_supplicant_state_txt(enum wpa_states state)
 536 {
 537         switch (state) {
 538         case WPA_DISCONNECTED:
 539                 return "DISCONNECTED";
 540         case WPA_INACTIVE:
 541                 return "INACTIVE";
 542         case WPA_INTERFACE_DISABLED:
 543                 return "INTERFACE_DISABLED";
 544         case WPA_SCANNING:
 545                 return "SCANNING";
 546         case WPA_AUTHENTICATING:
 547                 return "AUTHENTICATING";
 548         case WPA_ASSOCIATING:
 549                 return "ASSOCIATING";
 550         case WPA_ASSOCIATED:
 551                 return "ASSOCIATED";
 552         case WPA_4WAY_HANDSHAKE:
 553                 return "4WAY_HANDSHAKE";
 554         case WPA_GROUP_HANDSHAKE:
 555                 return "GROUP_HANDSHAKE";
 556         case WPA_COMPLETED:
 557                 return "COMPLETED";
 558         default:
 559                 return "UNKNOWN";
 560         }
 561 }
 562
 563
 564 #ifdef CONFIG_BGSCAN
 565
 566 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
 567 {
 568         if (wpas_driver_bss_selection(wpa_s))
 569                 return;
 570         if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
 571                 return;
 572
 573         bgscan_deinit(wpa_s);
 574         if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan) {
 575                 if (bgscan_init(wpa_s, wpa_s->current_ssid)) {
 576                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
 577                                 "bgscan");
 578                         /*
 579                          * Live without bgscan; it is only used as a roaming
 580                          * optimization, so the initial connection is not
 581                          * affected.
 582                          */
 583                 } else {
 584                         struct wpa_scan_results *scan_res;
 585                         wpa_s->bgscan_ssid = wpa_s->current_ssid;
 586                         scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
 587                                                                    0);
 588                         if (scan_res) {
 589                                 bgscan_notify_scan(wpa_s, scan_res);
 590                                 wpa_scan_results_free(scan_res);
 591                         }
 592                 }
 593         } else
 594                 wpa_s->bgscan_ssid = NULL;
 595 }
 596
 597
 598 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
 599 {
 600         if (wpa_s->bgscan_ssid != NULL) {
 601                 bgscan_deinit(wpa_s);
 602                 wpa_s->bgscan_ssid = NULL;
 603         }
 604 }
 605
 606 #endif /* CONFIG_BGSCAN */
 607
 608
 609 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
 610 {
 611         if (autoscan_init(wpa_s, 0))
 612                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
 613 }
 614
 615
 616 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
 617 {
 618         autoscan_deinit(wpa_s);
 619 }
 620
 621
 622 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
 623 {
 624         if (wpa_s->wpa_state == WPA_DISCONNECTED ||
 625             wpa_s->wpa_state == WPA_SCANNING) {
 626                 autoscan_deinit(wpa_s);
 627                 wpa_supplicant_start_autoscan(wpa_s);
 628         }
 629 }
 630
 631
 632 /**
 633  * wpa_supplicant_set_state - Set current connection state
 634  * @wpa_s: Pointer to wpa_supplicant data
 635  * @state: The new connection state
 636  *
 637  * This function is called whenever the connection state changes, e.g.,
 638  * association is completed for WPA/WPA2 4-Way Handshake is started.
 639  */
 640 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
 641                               enum wpa_states state)
 642 {
 643         enum wpa_states old_state = wpa_s->wpa_state;
 644
 645         wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
 646                 wpa_supplicant_state_txt(wpa_s->wpa_state),
 647                 wpa_supplicant_state_txt(state));
 648
 649         if (state != WPA_SCANNING)
 650                 wpa_supplicant_notify_scanning(wpa_s, 0);
 651
 652         if (state == WPA_COMPLETED && wpa_s->new_connection) {
 653 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 654                 struct wpa_ssid *ssid = wpa_s->current_ssid;
 655                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
 656                         MACSTR " completed %s [id=%d id_str=%s]",
 657                         MAC2STR(wpa_s->bssid), wpa_s->reassociated_connection ?
 658                         "(reauth)" : "(auth)",
 659                         ssid ? ssid->id : -1,
 660                         ssid && ssid->id_str ? ssid->id_str : "");
 661 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 662                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
 663                 wpa_s->new_connection = 0;
 664                 wpa_s->reassociated_connection = 1;
 665                 wpa_drv_set_operstate(wpa_s, 1);
 666 #ifndef IEEE8021X_EAPOL
 667                 wpa_drv_set_supp_port(wpa_s, 1);
 668 #endif /* IEEE8021X_EAPOL */
 669                 wpa_s->after_wps = 0;
 670 #ifdef CONFIG_P2P
 671                 wpas_p2p_completed(wpa_s);
 672 #endif /* CONFIG_P2P */
 673
 674                 sme_sched_obss_scan(wpa_s, 1);
 675         } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
 676                    state == WPA_ASSOCIATED) {
 677                 wpa_s->new_connection = 1;
 678                 wpa_drv_set_operstate(wpa_s, 0);
 679 #ifndef IEEE8021X_EAPOL
 680                 wpa_drv_set_supp_port(wpa_s, 0);
 681 #endif /* IEEE8021X_EAPOL */
 682                 sme_sched_obss_scan(wpa_s, 0);
 683         }
 684         wpa_s->wpa_state = state;
 685
 686 #ifdef CONFIG_BGSCAN
 687         if (state == WPA_COMPLETED)
 688                 wpa_supplicant_start_bgscan(wpa_s);
 689         else
 690                 wpa_supplicant_stop_bgscan(wpa_s);
 691 #endif /* CONFIG_BGSCAN */
 692
 693         if (state == WPA_AUTHENTICATING)
 694                 wpa_supplicant_stop_autoscan(wpa_s);
 695
 696         if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
 697                 wpa_supplicant_start_autoscan(wpa_s);
 698
 699         if (wpa_s->wpa_state != old_state) {
 700                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 701
 702                 if (wpa_s->wpa_state == WPA_COMPLETED ||
 703                     old_state == WPA_COMPLETED)
 704                         wpas_notify_auth_changed(wpa_s);
 705         }
 706 }
 707
 708
 709 void wpa_supplicant_terminate_proc(struct wpa_global *global)
 710 {
 711         int pending = 0;
 712 #ifdef CONFIG_WPS
 713         struct wpa_supplicant *wpa_s = global->ifaces;
 714         while (wpa_s) {
 715                 if (wpas_wps_terminate_pending(wpa_s) == 1)
 716                         pending = 1;
 717                 wpa_s = wpa_s->next;
 718         }
 719 #endif /* CONFIG_WPS */
 720         if (pending)
 721                 return;
 722         eloop_terminate();
 723 }
 724
 725
 726 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
 727 {
 728         struct wpa_global *global = signal_ctx;
 729         wpa_supplicant_terminate_proc(global);
 730 }
 731
 732
 733 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
 734 {
 735         enum wpa_states old_state = wpa_s->wpa_state;
 736
 737         wpa_s->pairwise_cipher = 0;
 738         wpa_s->group_cipher = 0;
 739         wpa_s->mgmt_group_cipher = 0;
 740         wpa_s->key_mgmt = 0;
 741         if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
 742                 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
 743
 744         if (wpa_s->wpa_state != old_state)
 745                 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
 746 }
 747
 748
 749 /**
 750  * wpa_supplicant_reload_configuration - Reload configuration data
 751  * @wpa_s: Pointer to wpa_supplicant data
 752  * Returns: 0 on success or -1 if configuration parsing failed
 753  *
 754  * This function can be used to request that the configuration data is reloaded
 755  * (e.g., after configuration file change). This function is reloading
 756  * configuration only for one interface, so this may need to be called multiple
 757  * times if %wpa_supplicant is controlling multiple interfaces and all
 758  * interfaces need reconfiguration.
 759  */
 760 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
 761 {
 762         struct wpa_config *conf;
 763         int reconf_ctrl;
 764         int old_ap_scan;
 765
 766         if (wpa_s->confname == NULL)
 767                 return -1;
 768         conf = wpa_config_read(wpa_s->confname);
 769         if (conf == NULL) {
 770                 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
 771                         "file '%s' - exiting", wpa_s->confname);
 772                 return -1;
 773         }
 774         conf->changed_parameters = (unsigned int) -1;
 775
 776         reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
 777                 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
 778                     os_strcmp(conf->ctrl_interface,
 779                               wpa_s->conf->ctrl_interface) != 0);
 780
 781         if (reconf_ctrl && wpa_s->ctrl_iface) {
 782                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
 783                 wpa_s->ctrl_iface = NULL;
 784         }
 785
 786         eapol_sm_invalidate_cached_session(wpa_s->eapol);
 787         if (wpa_s->current_ssid) {
 788                 wpa_supplicant_deauthenticate(wpa_s,
 789                                               WLAN_REASON_DEAUTH_LEAVING);
 790         }
 791
 792         /*
 793          * TODO: should notify EAPOL SM about changes in opensc_engine_path,
 794          * pkcs11_engine_path, pkcs11_module_path.
 795          */
 796         if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
 797                 /*
 798                  * Clear forced success to clear EAP state for next
 799                  * authentication.
 800                  */
 801                 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
 802         }
 803         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
 804         wpa_sm_set_config(wpa_s->wpa, NULL);
 805         wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
 806         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
 807         rsn_preauth_deinit(wpa_s->wpa);
 808
 809         old_ap_scan = wpa_s->conf->ap_scan;
 810         wpa_config_free(wpa_s->conf);
 811         wpa_s->conf = conf;
 812         if (old_ap_scan != wpa_s->conf->ap_scan)
 813                 wpas_notify_ap_scan_changed(wpa_s);
 814
 815         if (reconf_ctrl)
 816                 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
 817
 818         wpa_supplicant_update_config(wpa_s);
 819
 820         wpa_supplicant_clear_status(wpa_s);
 821         if (wpa_supplicant_enabled_networks(wpa_s)) {
 822                 wpa_s->reassociate = 1;
 823                 wpa_supplicant_req_scan(wpa_s, 0, 0);
 824         }
 825         wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
 826         return 0;
 827 }
 828
 829
 830 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
 831 {
 832         struct wpa_global *global = signal_ctx;
 833         struct wpa_supplicant *wpa_s;
 834         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 835                 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
 836                         sig);
 837                 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
 838                         wpa_supplicant_terminate_proc(global);
 839                 }
 840         }
 841 }
 842
 843
 844 enum wpa_cipher cipher_suite2driver(int cipher)
 845 {
 846         switch (cipher) {
 847         case WPA_CIPHER_NONE:
 848                 return CIPHER_NONE;
 849         case WPA_CIPHER_WEP40:
 850                 return CIPHER_WEP40;
 851         case WPA_CIPHER_WEP104:
 852                 return CIPHER_WEP104;
 853         case WPA_CIPHER_CCMP:
 854                 return CIPHER_CCMP;
 855         case WPA_CIPHER_GCMP:
 856                 return CIPHER_GCMP;
 857         case WPA_CIPHER_TKIP:
 858         default:
 859                 return CIPHER_TKIP;
 860         }
 861 }
 862
 863
 864 enum wpa_key_mgmt key_mgmt2driver(int key_mgmt)
 865 {
 866         switch (key_mgmt) {
 867         case WPA_KEY_MGMT_NONE:
 868                 return KEY_MGMT_NONE;
 869         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 870                 return KEY_MGMT_802_1X_NO_WPA;
 871         case WPA_KEY_MGMT_IEEE8021X:
 872                 return KEY_MGMT_802_1X;
 873         case WPA_KEY_MGMT_WPA_NONE:
 874                 return KEY_MGMT_WPA_NONE;
 875         case WPA_KEY_MGMT_FT_IEEE8021X:
 876                 return KEY_MGMT_FT_802_1X;
 877         case WPA_KEY_MGMT_FT_PSK:
 878                 return KEY_MGMT_FT_PSK;
 879         case WPA_KEY_MGMT_IEEE8021X_SHA256:
 880                 return KEY_MGMT_802_1X_SHA256;
 881         case WPA_KEY_MGMT_PSK_SHA256:
 882                 return KEY_MGMT_PSK_SHA256;
 883         case WPA_KEY_MGMT_WPS:
 884                 return KEY_MGMT_WPS;
 885         case WPA_KEY_MGMT_PSK:
 886         default:
 887                 return KEY_MGMT_PSK;
 888         }
 889 }
 890
 891
 892 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
 893                                          struct wpa_ssid *ssid,
 894                                          struct wpa_ie_data *ie)
 895 {
 896         int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
 897         if (ret) {
 898                 if (ret == -2) {
 899                         wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
 900                                 "from association info");
 901                 }
 902                 return -1;
 903         }
 904
 905         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
 906                 "cipher suites");
 907         if (!(ie->group_cipher & ssid->group_cipher)) {
 908                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
 909                         "cipher 0x%x (mask 0x%x) - reject",
 910                         ie->group_cipher, ssid->group_cipher);
 911                 return -1;
 912         }
 913         if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
 914                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
 915                         "cipher 0x%x (mask 0x%x) - reject",
 916                         ie->pairwise_cipher, ssid->pairwise_cipher);
 917                 return -1;
 918         }
 919         if (!(ie->key_mgmt & ssid->key_mgmt)) {
 920                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
 921                         "management 0x%x (mask 0x%x) - reject",
 922                         ie->key_mgmt, ssid->key_mgmt);
 923                 return -1;
 924         }
 925
 926 #ifdef CONFIG_IEEE80211W
 927         if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
 928             ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
 929                 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
 930                         "that does not support management frame protection - "
 931                         "reject");
 932                 return -1;
 933         }
 934 #endif /* CONFIG_IEEE80211W */
 935
 936         return 0;
 937 }
 938
 939
 940 /**
 941  * wpa_supplicant_set_suites - Set authentication and encryption parameters
 942  * @wpa_s: Pointer to wpa_supplicant data
 943  * @bss: Scan results for the selected BSS, or %NULL if not available
 944  * @ssid: Configuration data for the selected network
 945  * @wpa_ie: Buffer for the WPA/RSN IE
 946  * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
 947  * used buffer length in case the functions returns success.
 948  * Returns: 0 on success or -1 on failure
 949  *
 950  * This function is used to configure authentication and encryption parameters
 951  * based on the network configuration and scan result for the selected BSS (if
 952  * available).
 953  */
 954 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 955                               struct wpa_bss *bss, struct wpa_ssid *ssid,
 956                               u8 *wpa_ie, size_t *wpa_ie_len)
 957 {
 958         struct wpa_ie_data ie;
 959         int sel, proto;
 960         const u8 *bss_wpa, *bss_rsn;
 961
 962         if (bss) {
 963                 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
 964                 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
 965         } else
 966                 bss_wpa = bss_rsn = NULL;
 967
 968         if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
 969             wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[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, "RSN: using IEEE 802.11i/D9.0");
 974                 proto = WPA_PROTO_RSN;
 975         } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
 976                    wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 &&
 977                    (ie.group_cipher & ssid->group_cipher) &&
 978                    (ie.pairwise_cipher & ssid->pairwise_cipher) &&
 979                    (ie.key_mgmt & ssid->key_mgmt)) {
 980                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
 981                 proto = WPA_PROTO_WPA;
 982         } else if (bss) {
 983                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
 984                 return -1;
 985         } else {
 986                 if (ssid->proto & WPA_PROTO_RSN)
 987                         proto = WPA_PROTO_RSN;
 988                 else
 989                         proto = WPA_PROTO_WPA;
 990                 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
 991                         os_memset(&ie, 0, sizeof(ie));
 992                         ie.group_cipher = ssid->group_cipher;
 993                         ie.pairwise_cipher = ssid->pairwise_cipher;
 994                         ie.key_mgmt = ssid->key_mgmt;
 995 #ifdef CONFIG_IEEE80211W
 996                         ie.mgmt_group_cipher =
 997                                 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
 998                                 WPA_CIPHER_AES_128_CMAC : 0;
 999 #endif /* CONFIG_IEEE80211W */
1000                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1001                                 "based on configuration");
1002                 } else
1003                         proto = ie.proto;
1004         }
1005
1006         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1007                 "pairwise %d key_mgmt %d proto %d",
1008                 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
1009 #ifdef CONFIG_IEEE80211W
1010         if (ssid->ieee80211w) {
1011                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1012                         ie.mgmt_group_cipher);
1013         }
1014 #endif /* CONFIG_IEEE80211W */
1015
1016         wpa_s->wpa_proto = proto;
1017         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1018         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1019                          !!(ssid->proto & WPA_PROTO_RSN));
1020
1021         if (bss || !wpa_s->ap_ies_from_associnfo) {
1022                 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1023                                          bss_wpa ? 2 + bss_wpa[1] : 0) ||
1024                     wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1025                                          bss_rsn ? 2 + bss_rsn[1] : 0))
1026                         return -1;
1027         }
1028
1029         sel = ie.group_cipher & ssid->group_cipher;
1030         if (sel & WPA_CIPHER_CCMP) {
1031                 wpa_s->group_cipher = WPA_CIPHER_CCMP;
1032                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK CCMP");
1033         } else if (sel & WPA_CIPHER_GCMP) {
1034                 wpa_s->group_cipher = WPA_CIPHER_GCMP;
1035                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK GCMP");
1036         } else if (sel & WPA_CIPHER_TKIP) {
1037                 wpa_s->group_cipher = WPA_CIPHER_TKIP;
1038                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK TKIP");
1039         } else if (sel & WPA_CIPHER_WEP104) {
1040                 wpa_s->group_cipher = WPA_CIPHER_WEP104;
1041                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP104");
1042         } else if (sel & WPA_CIPHER_WEP40) {
1043                 wpa_s->group_cipher = WPA_CIPHER_WEP40;
1044                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK WEP40");
1045         } else {
1046                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1047                         "cipher");
1048                 return -1;
1049         }
1050
1051         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
1052         if (sel & WPA_CIPHER_CCMP) {
1053                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
1054                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK CCMP");
1055         } else if (sel & WPA_CIPHER_GCMP) {
1056                 wpa_s->pairwise_cipher = WPA_CIPHER_GCMP;
1057                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK GCMP");
1058         } else if (sel & WPA_CIPHER_TKIP) {
1059                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
1060                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK TKIP");
1061         } else if (sel & WPA_CIPHER_NONE) {
1062                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1063                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK NONE");
1064         } else {
1065                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1066                         "cipher");
1067                 return -1;
1068         }
1069
1070         sel = ie.key_mgmt & ssid->key_mgmt;
1071         if (0) {
1072 #ifdef CONFIG_IEEE80211R
1073         } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1074                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1075                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1076         } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1077                 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1078                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1079 #endif /* CONFIG_IEEE80211R */
1080 #ifdef CONFIG_IEEE80211W
1081         } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1082                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1083                 wpa_dbg(wpa_s, MSG_DEBUG,
1084                         "WPA: using KEY_MGMT 802.1X with SHA256");
1085         } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1086                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1087                 wpa_dbg(wpa_s, MSG_DEBUG,
1088                         "WPA: using KEY_MGMT PSK with SHA256");
1089 #endif /* CONFIG_IEEE80211W */
1090         } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1091                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1092                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1093         } else if (sel & WPA_KEY_MGMT_PSK) {
1094                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1095                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1096         } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1097                 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1098                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
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 == NO_MGMT_FRAME_PROTECTION ||
1113             !(ie.capabilities & WPA_CAPABILITY_MFPC))
1114                 sel = 0;
1115         if (sel & WPA_CIPHER_AES_128_CMAC) {
1116                 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1117                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1118                         "AES-128-CMAC");
1119         } else {
1120                 wpa_s->mgmt_group_cipher = 0;
1121                 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1122         }
1123         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1124                          wpa_s->mgmt_group_cipher);
1125         wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, ssid->ieee80211w);
1126 #endif /* CONFIG_IEEE80211W */
1127
1128         if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1129                 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1130                 return -1;
1131         }
1132
1133         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
1134                 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN);
1135 #ifndef CONFIG_NO_PBKDF2
1136                 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1137                     ssid->passphrase) {
1138                         u8 psk[PMK_LEN];
1139                         pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1140                                     4096, psk, PMK_LEN);
1141                         wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1142                                         psk, PMK_LEN);
1143                         wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1144                 }
1145 #endif /* CONFIG_NO_PBKDF2 */
1146 #ifdef CONFIG_EXT_PASSWORD
1147                 if (ssid->ext_psk) {
1148                         struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1149                                                              ssid->ext_psk);
1150                         char pw_str[64 + 1];
1151                         u8 psk[PMK_LEN];
1152
1153                         if (pw == NULL) {
1154                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1155                                         "found from external storage");
1156                                 return -1;
1157                         }
1158
1159                         if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1160                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1161                                         "PSK length %d in external storage",
1162                                         (int) wpabuf_len(pw));
1163                                 ext_password_free(pw);
1164                                 return -1;
1165                         }
1166
1167                         os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1168                         pw_str[wpabuf_len(pw)] = '\0';
1169
1170 #ifndef CONFIG_NO_PBKDF2
1171                         if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1172                         {
1173                                 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1174                                             4096, psk, PMK_LEN);
1175                                 os_memset(pw_str, 0, sizeof(pw_str));
1176                                 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1177                                                 "external passphrase)",
1178                                                 psk, PMK_LEN);
1179                                 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1180                         } else
1181 #endif /* CONFIG_NO_PBKDF2 */
1182                         if (wpabuf_len(pw) == 2 * PMK_LEN) {
1183                                 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1184                                         wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1185                                                 "Invalid PSK hex string");
1186                                         os_memset(pw_str, 0, sizeof(pw_str));
1187                                         ext_password_free(pw);
1188                                         return -1;
1189                                 }
1190                                 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN);
1191                         } else {
1192                                 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1193                                         "PSK available");
1194                                 os_memset(pw_str, 0, sizeof(pw_str));
1195                                 ext_password_free(pw);
1196                                 return -1;
1197                         }
1198
1199                         os_memset(pw_str, 0, sizeof(pw_str));
1200                         ext_password_free(pw);
1201                 }
1202 #endif /* CONFIG_EXT_PASSWORD */
1203         } else
1204                 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1205
1206         return 0;
1207 }
1208
1209
1210 /**
1211  * wpa_supplicant_associate - Request association
1212  * @wpa_s: Pointer to wpa_supplicant data
1213  * @bss: Scan results for the selected BSS, or %NULL if not available
1214  * @ssid: Configuration data for the selected network
1215  *
1216  * This function is used to request %wpa_supplicant to associate with a BSS.
1217  */
1218 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1219                               struct wpa_bss *bss, struct wpa_ssid *ssid)
1220 {
1221         u8 wpa_ie[200];
1222         size_t wpa_ie_len;
1223         int use_crypt, ret, i, bssid_changed;
1224         int algs = WPA_AUTH_ALG_OPEN;
1225         enum wpa_cipher cipher_pairwise, cipher_group;
1226         struct wpa_driver_associate_params params;
1227         int wep_keys_set = 0;
1228         struct wpa_driver_capa capa;
1229         int assoc_failed = 0;
1230         struct wpa_ssid *old_ssid;
1231 #ifdef CONFIG_HT_OVERRIDES
1232         struct ieee80211_ht_capabilities htcaps;
1233         struct ieee80211_ht_capabilities htcaps_mask;
1234 #endif /* CONFIG_HT_OVERRIDES */
1235
1236 #ifdef CONFIG_IBSS_RSN
1237         ibss_rsn_deinit(wpa_s->ibss_rsn);
1238         wpa_s->ibss_rsn = NULL;
1239 #endif /* CONFIG_IBSS_RSN */
1240
1241         if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1242             ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1243 #ifdef CONFIG_AP
1244                 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1245                         wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1246                                 "mode");
1247                         return;
1248                 }
1249                 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1250                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1251                         return;
1252                 }
1253                 wpa_s->current_bss = bss;
1254 #else /* CONFIG_AP */
1255                 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1256                         "the build");
1257 #endif /* CONFIG_AP */
1258                 return;
1259         }
1260
1261 #ifdef CONFIG_TDLS
1262         if (bss)
1263                 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1264                                 bss->ie_len);
1265 #endif /* CONFIG_TDLS */
1266
1267         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1268             ssid->mode == IEEE80211_MODE_INFRA) {
1269                 sme_authenticate(wpa_s, bss, ssid);
1270                 return;
1271         }
1272
1273         os_memset(&params, 0, sizeof(params));
1274         wpa_s->reassociate = 0;
1275         if (bss && !wpas_driver_bss_selection(wpa_s)) {
1276 #ifdef CONFIG_IEEE80211R
1277                 const u8 *ie, *md = NULL;
1278 #endif /* CONFIG_IEEE80211R */
1279                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
1280                         " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
1281                         wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
1282                 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
1283                 os_memset(wpa_s->bssid, 0, ETH_ALEN);
1284                 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
1285                 if (bssid_changed)
1286                         wpas_notify_bssid_changed(wpa_s);
1287 #ifdef CONFIG_IEEE80211R
1288                 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
1289                 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
1290                         md = ie + 2;
1291                 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
1292                 if (md) {
1293                         /* Prepare for the next transition */
1294                         wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
1295                 }
1296 #endif /* CONFIG_IEEE80211R */
1297 #ifdef CONFIG_WPS
1298         } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
1299                    wpa_s->conf->ap_scan == 2 &&
1300                    (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
1301                 /* Use ap_scan==1 style network selection to find the network
1302                  */
1303                 wpa_s->scan_req = 2;
1304                 wpa_s->reassociate = 1;
1305                 wpa_supplicant_req_scan(wpa_s, 0, 0);
1306                 return;
1307 #endif /* CONFIG_WPS */
1308         } else {
1309                 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
1310                         wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
1311                 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1312         }
1313         wpa_supplicant_cancel_sched_scan(wpa_s);
1314         wpa_supplicant_cancel_scan(wpa_s);
1315
1316         /* Starting new association, so clear the possibly used WPA IE from the
1317          * previous association. */
1318         wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1319
1320 #ifdef IEEE8021X_EAPOL
1321         if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1322                 if (ssid->leap) {
1323                         if (ssid->non_leap == 0)
1324                                 algs = WPA_AUTH_ALG_LEAP;
1325                         else
1326                                 algs |= WPA_AUTH_ALG_LEAP;
1327                 }
1328         }
1329 #endif /* IEEE8021X_EAPOL */
1330         wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
1331         if (ssid->auth_alg) {
1332                 algs = ssid->auth_alg;
1333                 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
1334                         "0x%x", algs);
1335         }
1336
1337         if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
1338                     wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
1339             wpa_key_mgmt_wpa(ssid->key_mgmt)) {
1340                 int try_opportunistic;
1341                 try_opportunistic = ssid->proactive_key_caching &&
1342                         (ssid->proto & WPA_PROTO_RSN);
1343                 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
1344                                             wpa_s->current_ssid,
1345                                             try_opportunistic) == 0)
1346                         eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
1347                 wpa_ie_len = sizeof(wpa_ie);
1348                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
1349                                               wpa_ie, &wpa_ie_len)) {
1350                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1351                                 "key management and encryption suites");
1352                         return;
1353                 }
1354         } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
1355                    wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
1356                 /*
1357                  * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1358                  * use non-WPA since the scan results did not indicate that the
1359                  * AP is using WPA or WPA2.
1360                  */
1361                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1362                 wpa_ie_len = 0;
1363                 wpa_s->wpa_proto = 0;
1364         } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
1365                 wpa_ie_len = sizeof(wpa_ie);
1366                 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
1367                                               wpa_ie, &wpa_ie_len)) {
1368                         wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
1369                                 "key management and encryption suites (no "
1370                                 "scan results)");
1371                         return;
1372                 }
1373 #ifdef CONFIG_WPS
1374         } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
1375                 struct wpabuf *wps_ie;
1376                 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
1377                 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
1378                         wpa_ie_len = wpabuf_len(wps_ie);
1379                         os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
1380                 } else
1381                         wpa_ie_len = 0;
1382                 wpabuf_free(wps_ie);
1383                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1384                 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
1385                         params.wps = WPS_MODE_PRIVACY;
1386                 else
1387                         params.wps = WPS_MODE_OPEN;
1388                 wpa_s->wpa_proto = 0;
1389 #endif /* CONFIG_WPS */
1390         } else {
1391                 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1392                 wpa_ie_len = 0;
1393                 wpa_s->wpa_proto = 0;
1394         }
1395
1396 #ifdef CONFIG_P2P
1397         if (wpa_s->global->p2p) {
1398                 u8 *pos;
1399                 size_t len;
1400                 int res;
1401                 pos = wpa_ie + wpa_ie_len;
1402                 len = sizeof(wpa_ie) - wpa_ie_len;
1403                 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
1404                                             ssid->p2p_group);
1405                 if (res >= 0)
1406                         wpa_ie_len += res;
1407         }
1408
1409         wpa_s->cross_connect_disallowed = 0;
1410         if (bss) {
1411                 struct wpabuf *p2p;
1412                 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1413                 if (p2p) {
1414                         wpa_s->cross_connect_disallowed =
1415                                 p2p_get_cross_connect_disallowed(p2p);
1416                         wpabuf_free(p2p);
1417                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
1418                                 "connection",
1419                                 wpa_s->cross_connect_disallowed ?
1420                                 "disallows" : "allows");
1421                 }
1422         }
1423 #endif /* CONFIG_P2P */
1424
1425 #ifdef CONFIG_HS20
1426         if (wpa_s->conf->hs20) {
1427                 struct wpabuf *hs20;
1428                 hs20 = wpabuf_alloc(20);
1429                 if (hs20) {
1430                         wpas_hs20_add_indication(hs20);
1431                         os_memcpy(wpa_ie + wpa_ie_len, wpabuf_head(hs20),
1432                                   wpabuf_len(hs20));
1433                         wpa_ie_len += wpabuf_len(hs20);
1434                         wpabuf_free(hs20);
1435                 }
1436         }
1437 #endif /* CONFIG_HS20 */
1438
1439 #ifdef CONFIG_INTERWORKING
1440         if (wpa_s->conf->interworking) {
1441                 u8 *pos = wpa_ie;
1442                 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
1443                         pos += 2 + pos[1];
1444                 os_memmove(pos + 6, pos, wpa_ie_len - (pos - wpa_ie));
1445                 wpa_ie_len += 6;
1446                 *pos++ = WLAN_EID_EXT_CAPAB;
1447                 *pos++ = 4;
1448                 *pos++ = 0x00;
1449                 *pos++ = 0x00;
1450                 *pos++ = 0x00;
1451                 *pos++ = 0x80; /* Bit 31 - Interworking */
1452         }
1453 #endif /* CONFIG_INTERWORKING */
1454
1455         wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
1456         use_crypt = 1;
1457         cipher_pairwise = cipher_suite2driver(wpa_s->pairwise_cipher);
1458         cipher_group = cipher_suite2driver(wpa_s->group_cipher);
1459         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1460             wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1461                 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
1462                         use_crypt = 0;
1463                 if (wpa_set_wep_keys(wpa_s, ssid)) {
1464                         use_crypt = 1;
1465                         wep_keys_set = 1;
1466                 }
1467         }
1468         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
1469                 use_crypt = 0;
1470
1471 #ifdef IEEE8021X_EAPOL
1472         if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
1473                 if ((ssid->eapol_flags &
1474                      (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
1475                       EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
1476                     !wep_keys_set) {
1477                         use_crypt = 0;
1478                 } else {
1479                         /* Assume that dynamic WEP-104 keys will be used and
1480                          * set cipher suites in order for drivers to expect
1481                          * encryption. */
1482                         cipher_pairwise = cipher_group = CIPHER_WEP104;
1483                 }
1484         }
1485 #endif /* IEEE8021X_EAPOL */
1486
1487         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1488                 /* Set the key before (and later after) association */
1489                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1490         }
1491
1492         wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
1493         if (bss) {
1494                 params.ssid = bss->ssid;
1495                 params.ssid_len = bss->ssid_len;
1496                 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
1497                         wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
1498                                    MACSTR " freq=%u MHz based on scan results "
1499                                    "(bssid_set=%d)",
1500                                    MAC2STR(bss->bssid), bss->freq,
1501                                    ssid->bssid_set);
1502                         params.bssid = bss->bssid;
1503                         params.freq = bss->freq;
1504                 }
1505         } else {
1506                 params.ssid = ssid->ssid;
1507                 params.ssid_len = ssid->ssid_len;
1508         }
1509
1510         if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
1511             wpa_s->conf->ap_scan == 2) {
1512                 params.bssid = ssid->bssid;
1513                 params.fixed_bssid = 1;
1514         }
1515
1516         if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
1517             params.freq == 0)
1518                 params.freq = ssid->frequency; /* Initial channel for IBSS */
1519         params.wpa_ie = wpa_ie;
1520         params.wpa_ie_len = wpa_ie_len;
1521         params.pairwise_suite = cipher_pairwise;
1522         params.group_suite = cipher_group;
1523         params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
1524         params.wpa_proto = wpa_s->wpa_proto;
1525         params.auth_alg = algs;
1526         params.mode = ssid->mode;
1527         params.bg_scan_period = ssid->bg_scan_period;
1528         for (i = 0; i < NUM_WEP_KEYS; i++) {
1529                 if (ssid->wep_key_len[i])
1530                         params.wep_key[i] = ssid->wep_key[i];
1531                 params.wep_key_len[i] = ssid->wep_key_len[i];
1532         }
1533         params.wep_tx_keyidx = ssid->wep_tx_keyidx;
1534
1535         if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1536             (params.key_mgmt_suite == KEY_MGMT_PSK ||
1537              params.key_mgmt_suite == KEY_MGMT_FT_PSK)) {
1538                 params.passphrase = ssid->passphrase;
1539                 if (ssid->psk_set)
1540                         params.psk = ssid->psk;
1541         }
1542
1543         params.drop_unencrypted = use_crypt;
1544
1545 #ifdef CONFIG_IEEE80211W
1546         params.mgmt_frame_protection = ssid->ieee80211w;
1547         if (ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION && bss) {
1548                 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1549                 struct wpa_ie_data ie;
1550                 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
1551                     ie.capabilities &
1552                     (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
1553                         wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
1554                                 "MFP: require MFP");
1555                         params.mgmt_frame_protection =
1556                                 MGMT_FRAME_PROTECTION_REQUIRED;
1557                 }
1558         }
1559 #endif /* CONFIG_IEEE80211W */
1560
1561         params.p2p = ssid->p2p_group;
1562
1563         if (wpa_s->parent->set_sta_uapsd)
1564                 params.uapsd = wpa_s->parent->sta_uapsd;
1565         else
1566                 params.uapsd = -1;
1567
1568 #ifdef CONFIG_HT_OVERRIDES
1569         os_memset(&htcaps, 0, sizeof(htcaps));
1570         os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
1571         params.htcaps = (u8 *) &htcaps;
1572         params.htcaps_mask = (u8 *) &htcaps_mask;
1573         wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
1574 #endif /* CONFIG_HT_OVERRIDES */
1575
1576         ret = wpa_drv_associate(wpa_s, &params);
1577         if (ret < 0) {
1578                 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
1579                         "failed");
1580                 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
1581                         /*
1582                          * The driver is known to mean what is saying, so we
1583                          * can stop right here; the association will not
1584                          * succeed.
1585                          */
1586                         wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
1587                         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1588                         os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1589                         return;
1590                 }
1591                 /* try to continue anyway; new association will be tried again
1592                  * after timeout */
1593                 assoc_failed = 1;
1594         }
1595
1596         if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1597                 /* Set the key after the association just in case association
1598                  * cleared the previously configured key. */
1599                 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
1600                 /* No need to timeout authentication since there is no key
1601                  * management. */
1602                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1603                 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1604 #ifdef CONFIG_IBSS_RSN
1605         } else if (ssid->mode == WPAS_MODE_IBSS &&
1606                    wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1607                    wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
1608                 /*
1609                  * RSN IBSS authentication is per-STA and we can disable the
1610                  * per-BSSID authentication.
1611                  */
1612                 wpa_supplicant_cancel_auth_timeout(wpa_s);
1613 #endif /* CONFIG_IBSS_RSN */
1614         } else {
1615                 /* Timeout for IEEE 802.11 authentication and association */
1616                 int timeout = 60;
1617
1618                 if (assoc_failed) {
1619                         /* give IBSS a bit more time */
1620                         timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
1621                 } else if (wpa_s->conf->ap_scan == 1) {
1622                         /* give IBSS a bit more time */
1623                         timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
1624                 }
1625                 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
1626         }
1627
1628         if (wep_keys_set && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1629             capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC) {
1630                 /* Set static WEP keys again */
1631                 wpa_set_wep_keys(wpa_s, ssid);
1632         }
1633
1634         if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
1635                 /*
1636                  * Do not allow EAP session resumption between different
1637                  * network configurations.
1638                  */
1639                 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1640         }
1641         old_ssid = wpa_s->current_ssid;
1642         wpa_s->current_ssid = ssid;
1643         wpa_s->current_bss = bss;
1644         wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
1645         wpa_supplicant_initiate_eapol(wpa_s);
1646         if (old_ssid != wpa_s->current_ssid)
1647                 wpas_notify_network_changed(wpa_s);
1648 }
1649
1650
1651 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
1652                                             const u8 *addr)
1653 {
1654         struct wpa_ssid *old_ssid;
1655
1656         wpa_clear_keys(wpa_s, addr);
1657         old_ssid = wpa_s->current_ssid;
1658         wpa_supplicant_mark_disassoc(wpa_s);
1659         wpa_sm_set_config(wpa_s->wpa, NULL);
1660         eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1661         if (old_ssid != wpa_s->current_ssid)
1662                 wpas_notify_network_changed(wpa_s);
1663         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
1664 }
1665
1666
1667 /**
1668  * wpa_supplicant_disassociate - Disassociate the current connection
1669  * @wpa_s: Pointer to wpa_supplicant data
1670  * @reason_code: IEEE 802.11 reason code for the disassociate frame
1671  *
1672  * This function is used to request %wpa_supplicant to disassociate with the
1673  * current AP.
1674  */
1675 void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
1676                                  int reason_code)
1677 {
1678         u8 *addr = NULL;
1679         union wpa_event_data event;
1680
1681         if (!is_zero_ether_addr(wpa_s->bssid)) {
1682                 wpa_drv_disassociate(wpa_s, wpa_s->bssid, reason_code);
1683                 addr = wpa_s->bssid;
1684                 os_memset(&event, 0, sizeof(event));
1685                 event.disassoc_info.reason_code = (u16) reason_code;
1686                 event.disassoc_info.locally_generated = 1;
1687                 wpa_supplicant_event(wpa_s, EVENT_DISASSOC, &event);
1688         }
1689
1690         wpa_supplicant_clear_connection(wpa_s, addr);
1691 }
1692
1693
1694 /**
1695  * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1696  * @wpa_s: Pointer to wpa_supplicant data
1697  * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1698  *
1699  * This function is used to request %wpa_supplicant to deauthenticate from the
1700  * current AP.
1701  */
1702 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
1703                                    int reason_code)
1704 {
1705         u8 *addr = NULL;
1706         union wpa_event_data event;
1707
1708         if (!is_zero_ether_addr(wpa_s->bssid)) {
1709                 wpa_drv_deauthenticate(wpa_s, wpa_s->bssid, reason_code);
1710                 addr = wpa_s->bssid;
1711                 os_memset(&event, 0, sizeof(event));
1712                 event.deauth_info.reason_code = (u16) reason_code;
1713                 event.deauth_info.locally_generated = 1;
1714                 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
1715         }
1716
1717         wpa_supplicant_clear_connection(wpa_s, addr);
1718 }
1719
1720
1721 /**
1722  * wpa_supplicant_enable_network - Mark a configured network as enabled
1723  * @wpa_s: wpa_supplicant structure for a network interface
1724  * @ssid: wpa_ssid structure for a configured network or %NULL
1725  *
1726  * Enables the specified network or all networks if no network specified.
1727  */
1728 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
1729                                    struct wpa_ssid *ssid)
1730 {
1731         struct wpa_ssid *other_ssid;
1732         int was_disabled;
1733
1734         if (ssid == NULL) {
1735                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1736                      other_ssid = other_ssid->next) {
1737                         if (other_ssid->disabled == 2)
1738                                 continue; /* do not change persistent P2P group
1739                                            * data */
1740                         if (other_ssid == wpa_s->current_ssid &&
1741                             other_ssid->disabled)
1742                                 wpa_s->reassociate = 1;
1743
1744                         was_disabled = other_ssid->disabled;
1745
1746                         other_ssid->disabled = 0;
1747                         if (was_disabled)
1748                                 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
1749
1750                         if (was_disabled != other_ssid->disabled)
1751                                 wpas_notify_network_enabled_changed(
1752                                         wpa_s, other_ssid);
1753                 }
1754                 if (wpa_s->reassociate)
1755                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1756         } else if (ssid->disabled && ssid->disabled != 2) {
1757                 if (wpa_s->current_ssid == NULL) {
1758                         /*
1759                          * Try to reassociate since there is no current
1760                          * configuration and a new network was made available.
1761                          */
1762                         wpa_s->reassociate = 1;
1763                         wpa_supplicant_req_scan(wpa_s, 0, 0);
1764                 }
1765
1766                 was_disabled = ssid->disabled;
1767
1768                 ssid->disabled = 0;
1769                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1770
1771                 if (was_disabled != ssid->disabled)
1772                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1773         }
1774 }
1775
1776
1777 /**
1778  * wpa_supplicant_disable_network - Mark a configured network as disabled
1779  * @wpa_s: wpa_supplicant structure for a network interface
1780  * @ssid: wpa_ssid structure for a configured network or %NULL
1781  *
1782  * Disables the specified network or all networks if no network specified.
1783  */
1784 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
1785                                     struct wpa_ssid *ssid)
1786 {
1787         struct wpa_ssid *other_ssid;
1788         int was_disabled;
1789
1790         if (ssid == NULL) {
1791                 for (other_ssid = wpa_s->conf->ssid; other_ssid;
1792                      other_ssid = other_ssid->next) {
1793                         was_disabled = other_ssid->disabled;
1794                         if (was_disabled == 2)
1795                                 continue; /* do not change persistent P2P group
1796                                            * data */
1797
1798                         other_ssid->disabled = 1;
1799
1800                         if (was_disabled != other_ssid->disabled)
1801                                 wpas_notify_network_enabled_changed(
1802                                         wpa_s, other_ssid);
1803                 }
1804                 if (wpa_s->current_ssid)
1805                         wpa_supplicant_disassociate(
1806                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1807         } else if (ssid->disabled != 2) {
1808                 if (ssid == wpa_s->current_ssid)
1809                         wpa_supplicant_disassociate(
1810                                 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1811
1812                 was_disabled = ssid->disabled;
1813
1814                 ssid->disabled = 1;
1815
1816                 if (was_disabled != ssid->disabled)
1817                         wpas_notify_network_enabled_changed(wpa_s, ssid);
1818         }
1819 }
1820
1821
1822 /**
1823  * wpa_supplicant_select_network - Attempt association with a network
1824  * @wpa_s: wpa_supplicant structure for a network interface
1825  * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1826  */
1827 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
1828                                    struct wpa_ssid *ssid)
1829 {
1830
1831         struct wpa_ssid *other_ssid;
1832         int disconnected = 0;
1833
1834         if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
1835                 wpa_supplicant_disassociate(
1836                         wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1837                 disconnected = 1;
1838         }
1839
1840         if (ssid)
1841                 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1842
1843         /*
1844          * Mark all other networks disabled or mark all networks enabled if no
1845          * network specified.
1846          */
1847         for (other_ssid = wpa_s->conf->ssid; other_ssid;
1848              other_ssid = other_ssid->next) {
1849                 int was_disabled = other_ssid->disabled;
1850                 if (was_disabled == 2)
1851                         continue; /* do not change persistent P2P group data */
1852
1853                 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
1854                 if (was_disabled && !other_ssid->disabled)
1855                         wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
1856
1857                 if (was_disabled != other_ssid->disabled)
1858                         wpas_notify_network_enabled_changed(wpa_s, other_ssid);
1859         }
1860
1861         if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) {
1862                 /* We are already associated with the selected network */
1863                 wpa_printf(MSG_DEBUG, "Already associated with the "
1864                            "selected network - do nothing");
1865                 return;
1866         }
1867
1868         if (ssid)
1869                 wpa_s->current_ssid = ssid;
1870         wpa_s->connect_without_scan = NULL;
1871         wpa_s->disconnected = 0;
1872         wpa_s->reassociate = 1;
1873         wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
1874
1875         if (ssid)
1876                 wpas_notify_network_selected(wpa_s, ssid);
1877 }
1878
1879
1880 /**
1881  * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1882  * @wpa_s: wpa_supplicant structure for a network interface
1883  * @ap_scan: AP scan mode
1884  * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1885  *
1886  */
1887 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
1888 {
1889
1890         int old_ap_scan;
1891
1892         if (ap_scan < 0 || ap_scan > 2)
1893                 return -1;
1894
1895 #ifdef ANDROID
1896         if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
1897             wpa_s->wpa_state >= WPA_ASSOCIATING &&
1898             wpa_s->wpa_state < WPA_COMPLETED) {
1899                 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
1900                            "associating", wpa_s->conf->ap_scan, ap_scan);
1901                 return 0;
1902         }
1903 #endif /* ANDROID */
1904
1905         old_ap_scan = wpa_s->conf->ap_scan;
1906         wpa_s->conf->ap_scan = ap_scan;
1907
1908         if (old_ap_scan != wpa_s->conf->ap_scan)
1909                 wpas_notify_ap_scan_changed(wpa_s);
1910
1911         return 0;
1912 }
1913
1914
1915 /**
1916  * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
1917  * @wpa_s: wpa_supplicant structure for a network interface
1918  * @expire_age: Expiration age in seconds
1919  * Returns: 0 if succeed or -1 if expire_age has an invalid value
1920  *
1921  */
1922 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
1923                                           unsigned int bss_expire_age)
1924 {
1925         if (bss_expire_age < 10) {
1926                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
1927                         bss_expire_age);
1928                 return -1;
1929         }
1930         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
1931                 bss_expire_age);
1932         wpa_s->conf->bss_expiration_age = bss_expire_age;
1933
1934         return 0;
1935 }
1936
1937
1938 /**
1939  * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
1940  * @wpa_s: wpa_supplicant structure for a network interface
1941  * @expire_count: number of scans after which an unseen BSS is reclaimed
1942  * Returns: 0 if succeed or -1 if expire_count has an invalid value
1943  *
1944  */
1945 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
1946                                             unsigned int bss_expire_count)
1947 {
1948         if (bss_expire_count < 1) {
1949                 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
1950                         bss_expire_count);
1951                 return -1;
1952         }
1953         wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
1954                 bss_expire_count);
1955         wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
1956
1957         return 0;
1958 }
1959
1960
1961 /**
1962  * wpa_supplicant_set_scan_interval - Set scan interval
1963  * @wpa_s: wpa_supplicant structure for a network interface
1964  * @scan_interval: scan interval in seconds
1965  * Returns: 0 if succeed or -1 if scan_interval has an invalid value
1966  *
1967  */
1968 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
1969                                      int scan_interval)
1970 {
1971         if (scan_interval < 0) {
1972                 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
1973                         scan_interval);
1974                 return -1;
1975         }
1976         wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
1977                 scan_interval);
1978         wpa_s->scan_interval = scan_interval;
1979
1980         return 0;
1981 }
1982
1983
1984 /**
1985  * wpa_supplicant_set_debug_params - Set global debug params
1986  * @global: wpa_global structure
1987  * @debug_level: debug level
1988  * @debug_timestamp: determines if show timestamp in debug data
1989  * @debug_show_keys: determines if show keys in debug data
1990  * Returns: 0 if succeed or -1 if debug_level has wrong value
1991  */
1992 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
1993                                     int debug_timestamp, int debug_show_keys)
1994 {
1995
1996         int old_level, old_timestamp, old_show_keys;
1997
1998         /* check for allowed debuglevels */
1999         if (debug_level != MSG_EXCESSIVE &&
2000             debug_level != MSG_MSGDUMP &&
2001             debug_level != MSG_DEBUG &&
2002             debug_level != MSG_INFO &&
2003             debug_level != MSG_WARNING &&
2004             debug_level != MSG_ERROR)
2005                 return -1;
2006
2007         old_level = wpa_debug_level;
2008         old_timestamp = wpa_debug_timestamp;
2009         old_show_keys = wpa_debug_show_keys;
2010
2011         wpa_debug_level = debug_level;
2012         wpa_debug_timestamp = debug_timestamp ? 1 : 0;
2013         wpa_debug_show_keys = debug_show_keys ? 1 : 0;
2014
2015         if (wpa_debug_level != old_level)
2016                 wpas_notify_debug_level_changed(global);
2017         if (wpa_debug_timestamp != old_timestamp)
2018                 wpas_notify_debug_timestamp_changed(global);
2019         if (wpa_debug_show_keys != old_show_keys)
2020                 wpas_notify_debug_show_keys_changed(global);
2021
2022         return 0;
2023 }
2024
2025
2026 /**
2027  * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2028  * @wpa_s: Pointer to wpa_supplicant data
2029  * Returns: A pointer to the current network structure or %NULL on failure
2030  */
2031 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
2032 {
2033         struct wpa_ssid *entry;
2034         u8 ssid[MAX_SSID_LEN];
2035         int res;
2036         size_t ssid_len;
2037         u8 bssid[ETH_ALEN];
2038         int wired;
2039
2040         res = wpa_drv_get_ssid(wpa_s, ssid);
2041         if (res < 0) {
2042                 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
2043                         "driver");
2044                 return NULL;
2045         }
2046         ssid_len = res;
2047
2048         if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
2049                 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
2050                         "driver");
2051                 return NULL;
2052         }
2053
2054         wired = wpa_s->conf->ap_scan == 0 &&
2055                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
2056
2057         entry = wpa_s->conf->ssid;
2058         while (entry) {
2059                 if (!wpas_network_disabled(wpa_s, entry) &&
2060                     ((ssid_len == entry->ssid_len &&
2061                       os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
2062                     (!entry->bssid_set ||
2063                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2064                         return entry;
2065 #ifdef CONFIG_WPS
2066                 if (!wpas_network_disabled(wpa_s, entry) &&
2067                     (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
2068                     (entry->ssid == NULL || entry->ssid_len == 0) &&
2069                     (!entry->bssid_set ||
2070                      os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
2071                         return entry;
2072 #endif /* CONFIG_WPS */
2073
2074                 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
2075                     entry->ssid_len == 0 &&
2076                     os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
2077                         return entry;
2078
2079                 entry = entry->next;
2080         }
2081
2082         return NULL;
2083 }
2084
2085
2086 static int select_driver(struct wpa_supplicant *wpa_s, int i)
2087 {
2088         struct wpa_global *global = wpa_s->global;
2089
2090         if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
2091                 global->drv_priv[i] = wpa_drivers[i]->global_init();
2092                 if (global->drv_priv[i] == NULL) {
2093                         wpa_printf(MSG_ERROR, "Failed to initialize driver "
2094                                    "'%s'", wpa_drivers[i]->name);
2095                         return -1;
2096                 }
2097         }
2098
2099         wpa_s->driver = wpa_drivers[i];
2100         wpa_s->global_drv_priv = global->drv_priv[i];
2101
2102         return 0;
2103 }
2104
2105
2106 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
2107                                      const char *name)
2108 {
2109         int i;
2110         size_t len;
2111         const char *pos, *driver = name;
2112
2113         if (wpa_s == NULL)
2114                 return -1;
2115
2116         if (wpa_drivers[0] == NULL) {
2117                 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
2118                         "wpa_supplicant");
2119                 return -1;
2120         }
2121
2122         if (name == NULL) {
2123                 /* default to first driver in the list */
2124                 return select_driver(wpa_s, 0);
2125         }
2126
2127         do {
2128                 pos = os_strchr(driver, ',');
2129                 if (pos)
2130                         len = pos - driver;
2131                 else
2132                         len = os_strlen(driver);
2133
2134                 for (i = 0; wpa_drivers[i]; i++) {
2135                         if (os_strlen(wpa_drivers[i]->name) == len &&
2136                             os_strncmp(driver, wpa_drivers[i]->name, len) ==
2137                             0) {
2138                                 /* First driver that succeeds wins */
2139                                 if (select_driver(wpa_s, i) == 0)
2140                                         return 0;
2141                         }
2142                 }
2143
2144                 driver = pos + 1;
2145         } while (pos);
2146
2147         wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
2148         return -1;
2149 }
2150
2151
2152 /**
2153  * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2154  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2155  *      with struct wpa_driver_ops::init()
2156  * @src_addr: Source address of the EAPOL frame
2157  * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2158  * @len: Length of the EAPOL data
2159  *
2160  * This function is called for each received EAPOL frame. Most driver
2161  * interfaces rely on more generic OS mechanism for receiving frames through
2162  * l2_packet, but if such a mechanism is not available, the driver wrapper may
2163  * take care of received EAPOL frames and deliver them to the core supplicant
2164  * code by calling this function.
2165  */
2166 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
2167                              const u8 *buf, size_t len)
2168 {
2169         struct wpa_supplicant *wpa_s = ctx;
2170
2171         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
2172         wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
2173
2174         if (wpa_s->wpa_state < WPA_ASSOCIATED) {
2175                 /*
2176                  * There is possible race condition between receiving the
2177                  * association event and the EAPOL frame since they are coming
2178                  * through different paths from the driver. In order to avoid
2179                  * issues in trying to process the EAPOL frame before receiving
2180                  * association information, lets queue it for processing until
2181                  * the association event is received.
2182                  */
2183                 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
2184                         "of received EAPOL frame");
2185                 wpabuf_free(wpa_s->pending_eapol_rx);
2186                 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
2187                 if (wpa_s->pending_eapol_rx) {
2188                         os_get_time(&wpa_s->pending_eapol_rx_time);
2189                         os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
2190                                   ETH_ALEN);
2191                 }
2192                 return;
2193         }
2194
2195 #ifdef CONFIG_AP
2196         if (wpa_s->ap_iface) {
2197                 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
2198                 return;
2199         }
2200 #endif /* CONFIG_AP */
2201
2202         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
2203                 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
2204                         "no key management is configured");
2205                 return;
2206         }
2207
2208         if (wpa_s->eapol_received == 0 &&
2209             (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
2210              !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
2211              wpa_s->wpa_state != WPA_COMPLETED) &&
2212             (wpa_s->current_ssid == NULL ||
2213              wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
2214                 /* Timeout for completing IEEE 802.1X and WPA authentication */
2215                 wpa_supplicant_req_auth_timeout(
2216                         wpa_s,
2217                         (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2218                          wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
2219                          wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ?
2220                         70 : 10, 0);
2221         }
2222         wpa_s->eapol_received++;
2223
2224         if (wpa_s->countermeasures) {
2225                 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
2226                         "EAPOL packet");
2227                 return;
2228         }
2229
2230 #ifdef CONFIG_IBSS_RSN
2231         if (wpa_s->current_ssid &&
2232             wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
2233                 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
2234                 return;
2235         }
2236 #endif /* CONFIG_IBSS_RSN */
2237
2238         /* Source address of the incoming EAPOL frame could be compared to the
2239          * current BSSID. However, it is possible that a centralized
2240          * Authenticator could be using another MAC address than the BSSID of
2241          * an AP, so just allow any address to be used for now. The replies are
2242          * still sent to the current BSSID (if available), though. */
2243
2244         os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
2245         if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
2246             eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
2247                 return;
2248         wpa_drv_poll(wpa_s);
2249         if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
2250                 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
2251         else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2252                 /*
2253                  * Set portValid = TRUE here since we are going to skip 4-way
2254                  * handshake processing which would normally set portValid. We
2255                  * need this to allow the EAPOL state machines to be completed
2256                  * without going through EAPOL-Key handshake.
2257                  */
2258                 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
2259         }
2260 }
2261
2262
2263 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
2264 {
2265         if (wpa_s->driver->send_eapol) {
2266                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2267                 if (addr)
2268                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2269         } else if (!(wpa_s->drv_flags &
2270                      WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
2271                 l2_packet_deinit(wpa_s->l2);
2272                 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
2273                                            wpa_drv_get_mac_addr(wpa_s),
2274                                            ETH_P_EAPOL,
2275                                            wpa_supplicant_rx_eapol, wpa_s, 0);
2276                 if (wpa_s->l2 == NULL)
2277                         return -1;
2278         } else {
2279                 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
2280                 if (addr)
2281                         os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
2282         }
2283
2284         if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
2285                 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
2286                 return -1;
2287         }
2288
2289         wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
2290                 MAC2STR(wpa_s->own_addr));
2291         wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
2292
2293         return 0;
2294 }
2295
2296
2297 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
2298                                            const u8 *buf, size_t len)
2299 {
2300         struct wpa_supplicant *wpa_s = ctx;
2301         const struct l2_ethhdr *eth;
2302
2303         if (len < sizeof(*eth))
2304                 return;
2305         eth = (const struct l2_ethhdr *) buf;
2306
2307         if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
2308             !(eth->h_dest[0] & 0x01)) {
2309                 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2310                         " (bridge - not for this interface - ignore)",
2311                         MAC2STR(src_addr), MAC2STR(eth->h_dest));
2312                 return;
2313         }
2314
2315         wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
2316                 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
2317         wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
2318                                 len - sizeof(*eth));
2319 }
2320
2321
2322 /**
2323  * wpa_supplicant_driver_init - Initialize driver interface parameters
2324  * @wpa_s: Pointer to wpa_supplicant data
2325  * Returns: 0 on success, -1 on failure
2326  *
2327  * This function is called to initialize driver interface parameters.
2328  * wpa_drv_init() must have been called before this function to initialize the
2329  * driver interface.
2330  */
2331 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
2332 {
2333         static int interface_count = 0;
2334
2335         if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
2336                 return -1;
2337
2338         if (wpa_s->bridge_ifname[0]) {
2339                 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
2340                         "interface '%s'", wpa_s->bridge_ifname);
2341                 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname,
2342                                               wpa_s->own_addr,
2343                                               ETH_P_EAPOL,
2344                                               wpa_supplicant_rx_eapol_bridge,
2345                                               wpa_s, 1);
2346                 if (wpa_s->l2_br == NULL) {
2347                         wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
2348                                 "connection for the bridge interface '%s'",
2349                                 wpa_s->bridge_ifname);
2350                         return -1;
2351                 }
2352         }
2353
2354         wpa_clear_keys(wpa_s, NULL);
2355
2356         /* Make sure that TKIP countermeasures are not left enabled (could
2357          * happen if wpa_supplicant is killed during countermeasures. */
2358         wpa_drv_set_countermeasures(wpa_s, 0);
2359
2360         wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
2361         wpa_drv_flush_pmkid(wpa_s);
2362
2363         wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
2364         wpa_s->prev_scan_wildcard = 0;
2365
2366         if (wpa_supplicant_enabled_networks(wpa_s)) {
2367                 if (wpa_supplicant_delayed_sched_scan(wpa_s, interface_count,
2368                                                       100000))
2369                         wpa_supplicant_req_scan(wpa_s, interface_count,
2370                                                 100000);
2371                 interface_count++;
2372         } else
2373                 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2374
2375         return 0;
2376 }
2377
2378
2379 static int wpa_supplicant_daemon(const char *pid_file)
2380 {
2381         wpa_printf(MSG_DEBUG, "Daemonize..");
2382         return os_daemonize(pid_file);
2383 }
2384
2385
2386 static struct wpa_supplicant * wpa_supplicant_alloc(void)
2387 {
2388         struct wpa_supplicant *wpa_s;
2389
2390         wpa_s = os_zalloc(sizeof(*wpa_s));
2391         if (wpa_s == NULL)
2392                 return NULL;
2393         wpa_s->scan_req = 1;
2394         wpa_s->scan_interval = 5;
2395         wpa_s->new_connection = 1;
2396         wpa_s->parent = wpa_s;
2397         wpa_s->sched_scanning = 0;
2398
2399         return wpa_s;
2400 }
2401
2402
2403 #ifdef CONFIG_HT_OVERRIDES
2404
2405 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
2406                              struct ieee80211_ht_capabilities *htcaps,
2407                              struct ieee80211_ht_capabilities *htcaps_mask,
2408                              const char *ht_mcs)
2409 {
2410         /* parse ht_mcs into hex array */
2411         int i;
2412         const char *tmp = ht_mcs;
2413         char *end = NULL;
2414
2415         /* If ht_mcs is null, do not set anything */
2416         if (!ht_mcs)
2417                 return 0;
2418
2419         /* This is what we are setting in the kernel */
2420         os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
2421
2422         wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
2423
2424         for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2425                 errno = 0;
2426                 long v = strtol(tmp, &end, 16);
2427                 if (errno == 0) {
2428                         wpa_msg(wpa_s, MSG_DEBUG,
2429                                 "htcap value[%i]: %ld end: %p  tmp: %p",
2430                                 i, v, end, tmp);
2431                         if (end == tmp)
2432                                 break;
2433
2434                         htcaps->supported_mcs_set[i] = v;
2435                         tmp = end;
2436                 } else {
2437                         wpa_msg(wpa_s, MSG_ERROR,
2438                                 "Failed to parse ht-mcs: %s, error: %s\n",
2439                                 ht_mcs, strerror(errno));
2440                         return -1;
2441                 }
2442         }
2443
2444         /*
2445          * If we were able to parse any values, then set mask for the MCS set.
2446          */
2447         if (i) {
2448                 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
2449                           IEEE80211_HT_MCS_MASK_LEN - 1);
2450                 /* skip the 3 reserved bits */
2451                 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
2452                         0x1f;
2453         }
2454
2455         return 0;
2456 }
2457
2458
2459 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
2460                                  struct ieee80211_ht_capabilities *htcaps,
2461                                  struct ieee80211_ht_capabilities *htcaps_mask,
2462                                  int disabled)
2463 {
2464         u16 msk;
2465
2466         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
2467
2468         if (disabled == -1)
2469                 return 0;
2470
2471         msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
2472         htcaps_mask->ht_capabilities_info |= msk;
2473         if (disabled)
2474                 htcaps->ht_capabilities_info &= msk;
2475         else
2476                 htcaps->ht_capabilities_info |= msk;
2477
2478         return 0;
2479 }
2480
2481
2482 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
2483                                 struct ieee80211_ht_capabilities *htcaps,
2484                                 struct ieee80211_ht_capabilities *htcaps_mask,
2485                                 int factor)
2486 {
2487         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
2488
2489         if (factor == -1)
2490                 return 0;
2491
2492         if (factor < 0 || factor > 3) {
2493                 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
2494                         "Must be 0-3 or -1", factor);
2495                 return -EINVAL;
2496         }
2497
2498         htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
2499         htcaps->a_mpdu_params &= ~0x3;
2500         htcaps->a_mpdu_params |= factor & 0x3;
2501
2502         return 0;
2503 }
2504
2505
2506 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
2507                                  struct ieee80211_ht_capabilities *htcaps,
2508                                  struct ieee80211_ht_capabilities *htcaps_mask,
2509                                  int density)
2510 {
2511         wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
2512
2513         if (density == -1)
2514                 return 0;
2515
2516         if (density < 0 || density > 7) {
2517                 wpa_msg(wpa_s, MSG_ERROR,
2518                         "ampdu_density: %d out of range. Must be 0-7 or -1.",
2519                         density);
2520                 return -EINVAL;
2521         }
2522
2523         htcaps_mask->a_mpdu_params |= 0x1C;
2524         htcaps->a_mpdu_params &= ~(0x1C);
2525         htcaps->a_mpdu_params |= (density << 2) & 0x1C;
2526
2527         return 0;
2528 }
2529
2530
2531 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
2532                                 struct ieee80211_ht_capabilities *htcaps,
2533                                 struct ieee80211_ht_capabilities *htcaps_mask,
2534                                 int disabled)
2535 {
2536         /* Masking these out disables HT40 */
2537         u16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
2538                                HT_CAP_INFO_SHORT_GI40MHZ);
2539
2540         wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
2541
2542         if (disabled)
2543                 htcaps->ht_capabilities_info &= ~msk;
2544         else
2545                 htcaps->ht_capabilities_info |= msk;
2546
2547         htcaps_mask->ht_capabilities_info |= msk;
2548
2549         return 0;
2550 }
2551
2552
2553 void wpa_supplicant_apply_ht_overrides(
2554         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
2555         struct wpa_driver_associate_params *params)
2556 {
2557         struct ieee80211_ht_capabilities *htcaps;
2558         struct ieee80211_ht_capabilities *htcaps_mask;
2559
2560         if (!ssid)
2561                 return;
2562
2563         params->disable_ht = ssid->disable_ht;
2564         if (!params->htcaps || !params->htcaps_mask)
2565                 return;
2566
2567         htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
2568         htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
2569         wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
2570         wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
2571                               ssid->disable_max_amsdu);
2572         wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
2573         wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
2574         wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
2575 }
2576
2577 #endif /* CONFIG_HT_OVERRIDES */
2578
2579
2580 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
2581 {
2582 #ifdef PCSC_FUNCS
2583         size_t len;
2584
2585         if (!wpa_s->conf->pcsc_reader)
2586                 return 0;
2587
2588         wpa_s->scard = scard_init(SCARD_TRY_BOTH, wpa_s->conf->pcsc_reader);
2589         if (!wpa_s->scard)
2590                 return 1;
2591
2592         if (wpa_s->conf->pcsc_pin &&
2593             scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
2594                 scard_deinit(wpa_s->scard);
2595                 wpa_s->scard = NULL;
2596                 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
2597                 return -1;
2598         }
2599
2600         len = sizeof(wpa_s->imsi) - 1;
2601         if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
2602                 scard_deinit(wpa_s->scard);
2603                 wpa_s->scard = NULL;
2604                 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
2605                 return -1;
2606         }
2607         wpa_s->imsi[len] = '\0';
2608
2609         wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
2610
2611         wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
2612                    wpa_s->imsi, wpa_s->mnc_len);
2613
2614         wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
2615         eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
2616 #endif /* PCSC_FUNCS */
2617
2618         return 0;
2619 }
2620
2621
2622 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
2623 {
2624         char *val, *pos;
2625
2626         ext_password_deinit(wpa_s->ext_pw);
2627         wpa_s->ext_pw = NULL;
2628         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
2629
2630         if (!wpa_s->conf->ext_password_backend)
2631                 return 0;
2632
2633         val = os_strdup(wpa_s->conf->ext_password_backend);
2634         if (val == NULL)
2635                 return -1;
2636         pos = os_strchr(val, ':');
2637         if (pos)
2638                 *pos++ = '\0';
2639
2640         wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
2641
2642         wpa_s->ext_pw = ext_password_init(val, pos);
2643         os_free(val);
2644         if (wpa_s->ext_pw == NULL) {
2645                 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
2646                 return -1;
2647         }
2648         eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
2649
2650         return 0;
2651 }
2652
2653
2654 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
2655                                      struct wpa_interface *iface)
2656 {
2657         const char *ifname, *driver;
2658         struct wpa_driver_capa capa;
2659
2660         wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
2661                    "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
2662                    iface->confname ? iface->confname : "N/A",
2663                    iface->driver ? iface->driver : "default",
2664                    iface->ctrl_interface ? iface->ctrl_interface : "N/A",
2665                    iface->bridge_ifname ? iface->bridge_ifname : "N/A");
2666
2667         if (iface->confname) {
2668 #ifdef CONFIG_BACKEND_FILE
2669                 wpa_s->confname = os_rel2abs_path(iface->confname);
2670                 if (wpa_s->confname == NULL) {
2671                         wpa_printf(MSG_ERROR, "Failed to get absolute path "
2672                                    "for configuration file '%s'.",
2673                                    iface->confname);
2674                         return -1;
2675                 }
2676                 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
2677                            iface->confname, wpa_s->confname);
2678 #else /* CONFIG_BACKEND_FILE */
2679                 wpa_s->confname = os_strdup(iface->confname);
2680 #endif /* CONFIG_BACKEND_FILE */
2681                 wpa_s->conf = wpa_config_read(wpa_s->confname);
2682                 if (wpa_s->conf == NULL) {
2683                         wpa_printf(MSG_ERROR, "Failed to read or parse "
2684                                    "configuration '%s'.", wpa_s->confname);
2685                         return -1;
2686                 }
2687
2688                 /*
2689                  * Override ctrl_interface and driver_param if set on command
2690                  * line.
2691                  */
2692                 if (iface->ctrl_interface) {
2693                         os_free(wpa_s->conf->ctrl_interface);
2694                         wpa_s->conf->ctrl_interface =
2695                                 os_strdup(iface->ctrl_interface);
2696                 }
2697
2698                 if (iface->driver_param) {
2699                         os_free(wpa_s->conf->driver_param);
2700                         wpa_s->conf->driver_param =
2701                                 os_strdup(iface->driver_param);
2702                 }
2703         } else
2704                 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
2705                                                      iface->driver_param);
2706
2707         if (wpa_s->conf == NULL) {
2708                 wpa_printf(MSG_ERROR, "\nNo configuration found.");
2709                 return -1;
2710         }
2711
2712         if (iface->ifname == NULL) {
2713                 wpa_printf(MSG_ERROR, "\nInterface name is required.");
2714                 return -1;
2715         }
2716         if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
2717                 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
2718                            iface->ifname);
2719                 return -1;
2720         }
2721         os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
2722
2723         if (iface->bridge_ifname) {
2724                 if (os_strlen(iface->bridge_ifname) >=
2725                     sizeof(wpa_s->bridge_ifname)) {
2726                         wpa_printf(MSG_ERROR, "\nToo long bridge interface "
2727                                    "name '%s'.", iface->bridge_ifname);
2728                         return -1;
2729                 }
2730                 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
2731                            sizeof(wpa_s->bridge_ifname));
2732         }
2733
2734         /* RSNA Supplicant Key Management - INITIALIZE */
2735         eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
2736         eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
2737
2738         /* Initialize driver interface and register driver event handler before
2739          * L2 receive handler so that association events are processed before
2740          * EAPOL-Key packets if both become available for the same select()
2741          * call. */
2742         driver = iface->driver;
2743 next_driver:
2744         if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
2745                 return -1;
2746
2747         wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
2748         if (wpa_s->drv_priv == NULL) {
2749                 const char *pos;
2750                 pos = driver ? os_strchr(driver, ',') : NULL;
2751                 if (pos) {
2752                         wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
2753                                 "driver interface - try next driver wrapper");
2754                         driver = pos + 1;
2755                         goto next_driver;
2756                 }
2757                 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
2758                         "interface");
2759                 return -1;
2760         }
2761         if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
2762                 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
2763                         "driver_param '%s'", wpa_s->conf->driver_param);
2764                 return -1;
2765         }
2766
2767         ifname = wpa_drv_get_ifname(wpa_s);
2768         if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
2769                 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
2770                         "interface name with '%s'", ifname);
2771                 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
2772         }
2773
2774         if (wpa_supplicant_init_wpa(wpa_s) < 0)
2775                 return -1;
2776
2777         wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
2778                           wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
2779                           NULL);
2780         wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
2781
2782         if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
2783             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
2784                              wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
2785                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2786                         "dot11RSNAConfigPMKLifetime");
2787                 return -1;
2788         }
2789
2790         if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
2791             wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
2792                              wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
2793                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2794                         "dot11RSNAConfigPMKReauthThreshold");
2795                 return -1;
2796         }
2797
2798         if (wpa_s->conf->dot11RSNAConfigSATimeout &&
2799             wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
2800                              wpa_s->conf->dot11RSNAConfigSATimeout)) {
2801                 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
2802                         "dot11RSNAConfigSATimeout");
2803                 return -1;
2804         }
2805
2806         wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
2807                                                       &wpa_s->hw.num_modes,
2808                                                       &wpa_s->hw.flags);
2809
2810         if (wpa_drv_get_capa(wpa_s, &capa) == 0) {
2811                 wpa_s->drv_capa_known = 1;
2812                 wpa_s->drv_flags = capa.flags;
2813                 wpa_s->drv_enc = capa.enc;
2814                 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
2815                 wpa_s->max_scan_ssids = capa.max_scan_ssids;
2816                 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
2817                 wpa_s->sched_scan_supported = capa.sched_scan_supported;
2818                 wpa_s->max_match_sets = capa.max_match_sets;
2819                 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
2820                 wpa_s->max_stations = capa.max_stations;
2821         }
2822         if (wpa_s->max_remain_on_chan == 0)
2823                 wpa_s->max_remain_on_chan = 1000;
2824
2825         if (wpa_supplicant_driver_init(wpa_s) < 0)
2826                 return -1;
2827
2828 #ifdef CONFIG_TDLS
2829         if (wpa_tdls_init(wpa_s->wpa))
2830                 return -1;
2831 #endif /* CONFIG_TDLS */
2832
2833         if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
2834             wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
2835                 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
2836                 return -1;
2837         }
2838
2839         if (wpas_wps_init(wpa_s))
2840                 return -1;
2841
2842         if (wpa_supplicant_init_eapol(wpa_s) < 0)
2843                 return -1;
2844         wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2845
2846         wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
2847         if (wpa_s->ctrl_iface == NULL) {
2848                 wpa_printf(MSG_ERROR,
2849                            "Failed to initialize control interface '%s'.\n"
2850                            "You may have another wpa_supplicant process "
2851                            "already running or the file was\n"
2852                            "left by an unclean termination of wpa_supplicant "
2853                            "in which case you will need\n"
2854                            "to manually remove this file before starting "
2855                            "wpa_supplicant again.\n",
2856                            wpa_s->conf->ctrl_interface);
2857                 return -1;
2858         }
2859
2860         wpa_s->gas = gas_query_init(wpa_s);
2861         if (wpa_s->gas == NULL) {
2862                 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
2863                 return -1;
2864         }
2865
2866 #ifdef CONFIG_P2P
2867         if (wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
2868                 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
2869                 return -1;
2870         }
2871 #endif /* CONFIG_P2P */
2872
2873         if (wpa_bss_init(wpa_s) < 0)
2874                 return -1;
2875
2876         if (pcsc_reader_init(wpa_s) < 0)
2877                 return -1;
2878
2879         if (wpas_init_ext_pw(wpa_s) < 0)
2880                 return -1;
2881
2882         return 0;
2883 }
2884
2885
2886 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
2887                                         int notify, int terminate)
2888 {
2889         if (wpa_s->drv_priv) {
2890                 wpa_supplicant_deauthenticate(wpa_s,
2891                                               WLAN_REASON_DEAUTH_LEAVING);
2892
2893                 wpa_drv_set_countermeasures(wpa_s, 0);
2894                 wpa_clear_keys(wpa_s, NULL);
2895         }
2896
2897         wpa_supplicant_cleanup(wpa_s);
2898
2899 #ifdef CONFIG_P2P
2900         if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
2901                 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
2902                         "the management interface is being removed");
2903                 wpas_p2p_deinit_global(wpa_s->global);
2904         }
2905 #endif /* CONFIG_P2P */
2906
2907         if (wpa_s->drv_priv)
2908                 wpa_drv_deinit(wpa_s);
2909
2910         if (notify)
2911                 wpas_notify_iface_removed(wpa_s);
2912
2913         if (terminate)
2914                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
2915
2916         if (wpa_s->ctrl_iface) {
2917                 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
2918                 wpa_s->ctrl_iface = NULL;
2919         }
2920
2921         if (wpa_s->conf != NULL) {
2922                 wpa_config_free(wpa_s->conf);
2923                 wpa_s->conf = NULL;
2924         }
2925 }
2926
2927
2928 /**
2929  * wpa_supplicant_add_iface - Add a new network interface
2930  * @global: Pointer to global data from wpa_supplicant_init()
2931  * @iface: Interface configuration options
2932  * Returns: Pointer to the created interface or %NULL on failure
2933  *
2934  * This function is used to add new network interfaces for %wpa_supplicant.
2935  * This can be called before wpa_supplicant_run() to add interfaces before the
2936  * main event loop has been started. In addition, new interfaces can be added
2937  * dynamically while %wpa_supplicant is already running. This could happen,
2938  * e.g., when a hotplug network adapter is inserted.
2939  */
2940 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
2941                                                  struct wpa_interface *iface)
2942 {
2943         struct wpa_supplicant *wpa_s;
2944         struct wpa_interface t_iface;
2945         struct wpa_ssid *ssid;
2946
2947         if (global == NULL || iface == NULL)
2948                 return NULL;
2949
2950         wpa_s = wpa_supplicant_alloc();
2951         if (wpa_s == NULL)
2952                 return NULL;
2953
2954         wpa_s->global = global;
2955
2956         t_iface = *iface;
2957         if (global->params.override_driver) {
2958                 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
2959                            "('%s' -> '%s')",
2960                            iface->driver, global->params.override_driver);
2961                 t_iface.driver = global->params.override_driver;
2962         }
2963         if (global->params.override_ctrl_interface) {
2964                 wpa_printf(MSG_DEBUG, "Override interface parameter: "
2965                            "ctrl_interface ('%s' -> '%s')",
2966                            iface->ctrl_interface,
2967                            global->params.override_ctrl_interface);
2968                 t_iface.ctrl_interface =
2969                         global->params.override_ctrl_interface;
2970         }
2971         if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
2972                 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
2973                            iface->ifname);
2974                 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
2975                 os_free(wpa_s);
2976                 return NULL;
2977         }
2978
2979         /* Notify the control interfaces about new iface */
2980         if (wpas_notify_iface_added(wpa_s)) {
2981                 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
2982                 os_free(wpa_s);
2983                 return NULL;
2984         }
2985
2986         for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2987                 wpas_notify_network_added(wpa_s, ssid);
2988
2989         wpa_s->next = global->ifaces;
2990         global->ifaces = wpa_s;
2991
2992         wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
2993         wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2994
2995         return wpa_s;
2996 }
2997
2998
2999 /**
3000  * wpa_supplicant_remove_iface - Remove a network interface
3001  * @global: Pointer to global data from wpa_supplicant_init()
3002  * @wpa_s: Pointer to the network interface to be removed
3003  * Returns: 0 if interface was removed, -1 if interface was not found
3004  *
3005  * This function can be used to dynamically remove network interfaces from
3006  * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
3007  * addition, this function is used to remove all remaining interfaces when
3008  * %wpa_supplicant is terminated.
3009  */
3010 int wpa_supplicant_remove_iface(struct wpa_global *global,
3011                                 struct wpa_supplicant *wpa_s,
3012                                 int terminate)
3013 {
3014         struct wpa_supplicant *prev;
3015
3016         /* Remove interface from the global list of interfaces */
3017         prev = global->ifaces;
3018         if (prev == wpa_s) {
3019                 global->ifaces = wpa_s->next;
3020         } else {
3021                 while (prev && prev->next != wpa_s)
3022                         prev = prev->next;
3023                 if (prev == NULL)
3024                         return -1;
3025                 prev->next = wpa_s->next;
3026         }
3027
3028         wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
3029
3030         if (global->p2p_group_formation == wpa_s)
3031                 global->p2p_group_formation = NULL;
3032         wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
3033         os_free(wpa_s);
3034
3035         return 0;
3036 }
3037
3038
3039 /**
3040  * wpa_supplicant_get_eap_mode - Get the current EAP mode
3041  * @wpa_s: Pointer to the network interface
3042  * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
3043  */
3044 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
3045 {
3046         const char *eapol_method;
3047
3048         if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
3049             wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3050                 return "NO-EAP";
3051         }
3052
3053         eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
3054         if (eapol_method == NULL)
3055                 return "UNKNOWN-EAP";
3056
3057         return eapol_method;
3058 }
3059
3060
3061 /**
3062  * wpa_supplicant_get_iface - Get a new network interface
3063  * @global: Pointer to global data from wpa_supplicant_init()
3064  * @ifname: Interface name
3065  * Returns: Pointer to the interface or %NULL if not found
3066  */
3067 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
3068                                                  const char *ifname)
3069 {
3070         struct wpa_supplicant *wpa_s;
3071
3072         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3073                 if (os_strcmp(wpa_s->ifname, ifname) == 0)
3074                         return wpa_s;
3075         }
3076         return NULL;
3077 }
3078
3079
3080 #ifndef CONFIG_NO_WPA_MSG
3081 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
3082 {
3083         struct wpa_supplicant *wpa_s = ctx;
3084         if (wpa_s == NULL)
3085                 return NULL;
3086         return wpa_s->ifname;
3087 }
3088 #endif /* CONFIG_NO_WPA_MSG */
3089
3090
3091 /**
3092  * wpa_supplicant_init - Initialize %wpa_supplicant
3093  * @params: Parameters for %wpa_supplicant
3094  * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
3095  *
3096  * This function is used to initialize %wpa_supplicant. After successful
3097  * initialization, the returned data pointer can be used to add and remove
3098  * network interfaces, and eventually, to deinitialize %wpa_supplicant.
3099  */
3100 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
3101 {
3102         struct wpa_global *global;
3103         int ret, i;
3104
3105         if (params == NULL)
3106                 return NULL;
3107
3108 #ifdef CONFIG_DRIVER_NDIS
3109         {
3110                 void driver_ndis_init_ops(void);
3111                 driver_ndis_init_ops();
3112         }
3113 #endif /* CONFIG_DRIVER_NDIS */
3114
3115 #ifndef CONFIG_NO_WPA_MSG
3116         wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
3117 #endif /* CONFIG_NO_WPA_MSG */
3118
3119         wpa_debug_open_file(params->wpa_debug_file_path);
3120         if (params->wpa_debug_syslog)
3121                 wpa_debug_open_syslog();
3122         if (params->wpa_debug_tracing) {
3123                 ret = wpa_debug_open_linux_tracing();
3124                 if (ret) {
3125                         wpa_printf(MSG_ERROR,
3126                                    "Failed to enable trace logging");
3127                         return NULL;
3128                 }
3129         }
3130
3131         ret = eap_register_methods();
3132         if (ret) {
3133                 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
3134                 if (ret == -2)
3135                         wpa_printf(MSG_ERROR, "Two or more EAP methods used "
3136                                    "the same EAP type.");
3137                 return NULL;
3138         }
3139
3140         global = os_zalloc(sizeof(*global));
3141         if (global == NULL)
3142                 return NULL;
3143         dl_list_init(&global->p2p_srv_bonjour);
3144         dl_list_init(&global->p2p_srv_upnp);
3145         global->params.daemonize = params->daemonize;
3146         global->params.wait_for_monitor = params->wait_for_monitor;
3147         global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
3148         if (params->pid_file)
3149                 global->params.pid_file = os_strdup(params->pid_file);
3150         if (params->ctrl_interface)
3151                 global->params.ctrl_interface =
3152                         os_strdup(params->ctrl_interface);
3153         if (params->override_driver)
3154                 global->params.override_driver =
3155                         os_strdup(params->override_driver);
3156         if (params->override_ctrl_interface)
3157                 global->params.override_ctrl_interface =
3158                         os_strdup(params->override_ctrl_interface);
3159         wpa_debug_level = global->params.wpa_debug_level =
3160                 params->wpa_debug_level;
3161         wpa_debug_show_keys = global->params.wpa_debug_show_keys =
3162                 params->wpa_debug_show_keys;
3163         wpa_debug_timestamp = global->params.wpa_debug_timestamp =
3164                 params->wpa_debug_timestamp;
3165
3166         wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
3167
3168         if (eloop_init()) {
3169                 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
3170                 wpa_supplicant_deinit(global);
3171                 return NULL;
3172         }
3173
3174         random_init(params->entropy_file);
3175
3176         global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
3177         if (global->ctrl_iface == NULL) {
3178                 wpa_supplicant_deinit(global);
3179                 return NULL;
3180         }
3181
3182         if (wpas_notify_supplicant_initialized(global)) {
3183                 wpa_supplicant_deinit(global);
3184                 return NULL;
3185         }
3186
3187         for (i = 0; wpa_drivers[i]; i++)
3188                 global->drv_count++;
3189         if (global->drv_count == 0) {
3190                 wpa_printf(MSG_ERROR, "No drivers enabled");
3191                 wpa_supplicant_deinit(global);
3192                 return NULL;
3193         }
3194         global->drv_priv = os_zalloc(global->drv_count * sizeof(void *));
3195         if (global->drv_priv == NULL) {
3196                 wpa_supplicant_deinit(global);
3197                 return NULL;
3198         }
3199
3200 #ifdef CONFIG_WIFI_DISPLAY
3201         if (wifi_display_init(global) < 0) {
3202                 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
3203                 wpa_supplicant_deinit(global);
3204                 return NULL;
3205         }
3206 #endif /* CONFIG_WIFI_DISPLAY */
3207
3208         return global;
3209 }
3210
3211
3212 /**
3213  * wpa_supplicant_run - Run the %wpa_supplicant main event loop
3214  * @global: Pointer to global data from wpa_supplicant_init()
3215  * Returns: 0 after successful event loop run, -1 on failure
3216  *
3217  * This function starts the main event loop and continues running as long as
3218  * there are any remaining events. In most cases, this function is running as
3219  * long as the %wpa_supplicant process in still in use.
3220  */
3221 int wpa_supplicant_run(struct wpa_global *global)
3222 {
3223         struct wpa_supplicant *wpa_s;
3224
3225         if (global->params.daemonize &&
3226             wpa_supplicant_daemon(global->params.pid_file))
3227                 return -1;
3228
3229         if (global->params.wait_for_monitor) {
3230                 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
3231                         if (wpa_s->ctrl_iface)
3232                                 wpa_supplicant_ctrl_iface_wait(
3233                                         wpa_s->ctrl_iface);
3234         }
3235
3236         eloop_register_signal_terminate(wpa_supplicant_terminate, global);
3237         eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
3238
3239         eloop_run();
3240
3241         return 0;
3242 }
3243
3244
3245 /**
3246  * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
3247  * @global: Pointer to global data from wpa_supplicant_init()
3248  *
3249  * This function is called to deinitialize %wpa_supplicant and to free all
3250  * allocated resources. Remaining network interfaces will also be removed.
3251  */
3252 void wpa_supplicant_deinit(struct wpa_global *global)
3253 {
3254         int i;
3255
3256         if (global == NULL)
3257                 return;
3258
3259 #ifdef CONFIG_WIFI_DISPLAY
3260         wifi_display_deinit(global);
3261 #endif /* CONFIG_WIFI_DISPLAY */
3262 #ifdef CONFIG_P2P
3263         wpas_p2p_deinit_global(global);
3264 #endif /* CONFIG_P2P */
3265
3266         while (global->ifaces)
3267                 wpa_supplicant_remove_iface(global, global->ifaces, 1);
3268
3269         if (global->ctrl_iface)
3270                 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
3271
3272         wpas_notify_supplicant_deinitialized(global);
3273
3274         eap_peer_unregister_methods();
3275 #ifdef CONFIG_AP
3276         eap_server_unregister_methods();
3277 #endif /* CONFIG_AP */
3278
3279         for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
3280                 if (!global->drv_priv[i])
3281                         continue;
3282                 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
3283         }
3284         os_free(global->drv_priv);
3285
3286         random_deinit();
3287
3288         eloop_destroy();
3289
3290         if (global->params.pid_file) {
3291                 os_daemonize_terminate(global->params.pid_file);
3292                 os_free(global->params.pid_file);
3293         }
3294         os_free(global->params.ctrl_interface);
3295         os_free(global->params.override_driver);
3296         os_free(global->params.override_ctrl_interface);
3297
3298         os_free(global->p2p_disallow_freq);
3299
3300         os_free(global);
3301         wpa_debug_close_syslog();
3302         wpa_debug_close_file();
3303         wpa_debug_close_linux_tracing();
3304 }
3305
3306
3307 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
3308 {
3309         if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
3310             wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3311                 char country[3];
3312                 country[0] = wpa_s->conf->country[0];
3313                 country[1] = wpa_s->conf->country[1];
3314                 country[2] = '\0';
3315                 if (wpa_drv_set_country(wpa_s, country) < 0) {
3316                         wpa_printf(MSG_ERROR, "Failed to set country code "
3317                                    "'%s'", country);
3318                 }
3319         }
3320
3321         if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
3322                 wpas_init_ext_pw(wpa_s);
3323
3324 #ifdef CONFIG_WPS
3325         wpas_wps_update_config(wpa_s);
3326 #endif /* CONFIG_WPS */
3327
3328 #ifdef CONFIG_P2P
3329         wpas_p2p_update_config(wpa_s);
3330 #endif /* CONFIG_P2P */
3331
3332         wpa_s->conf->changed_parameters = 0;
3333 }
3334
3335
3336 static void add_freq(int *freqs, int *num_freqs, int freq)
3337 {
3338         int i;
3339
3340         for (i = 0; i < *num_freqs; i++) {
3341                 if (freqs[i] == freq)
3342                         return;
3343         }
3344
3345         freqs[*num_freqs] = freq;
3346         (*num_freqs)++;
3347 }
3348
3349
3350 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
3351 {
3352         struct wpa_bss *bss, *cbss;
3353         const int max_freqs = 10;
3354         int *freqs;
3355         int num_freqs = 0;
3356
3357         freqs = os_zalloc(sizeof(int) * (max_freqs + 1));
3358         if (freqs == NULL)
3359                 return NULL;
3360
3361         cbss = wpa_s->current_bss;
3362
3363         dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
3364                 if (bss == cbss)
3365                         continue;
3366                 if (bss->ssid_len == cbss->ssid_len &&
3367                     os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
3368                     wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
3369                         add_freq(freqs, &num_freqs, bss->freq);
3370                         if (num_freqs == max_freqs)
3371                                 break;
3372                 }
3373         }
3374
3375         if (num_freqs == 0) {
3376                 os_free(freqs);
3377                 freqs = NULL;
3378         }
3379
3380         return freqs;
3381 }
3382
3383
3384 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
3385 {
3386         int timeout;
3387         int count;
3388         int *freqs = NULL;
3389
3390         /*
3391          * Remove possible authentication timeout since the connection failed.
3392          */
3393         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3394
3395         /*
3396          * Add the failed BSSID into the blacklist and speed up next scan
3397          * attempt if there could be other APs that could accept association.
3398          * The current blacklist count indicates how many times we have tried
3399          * connecting to this AP and multiple attempts mean that other APs are
3400          * either not available or has already been tried, so that we can start
3401          * increasing the delay here to avoid constant scanning.
3402          */
3403         count = wpa_blacklist_add(wpa_s, bssid);
3404         if (count == 1 && wpa_s->current_bss) {
3405                 /*
3406                  * This BSS was not in the blacklist before. If there is
3407                  * another BSS available for the same ESS, we should try that
3408                  * next. Otherwise, we may as well try this one once more
3409                  * before allowing other, likely worse, ESSes to be considered.
3410                  */
3411                 freqs = get_bss_freqs_in_ess(wpa_s);
3412                 if (freqs) {
3413                         wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
3414                                 "has been seen; try it next");
3415                         wpa_blacklist_add(wpa_s, bssid);
3416                         /*
3417                          * On the next scan, go through only the known channels
3418                          * used in this ESS based on previous scans to speed up
3419                          * common load balancing use case.
3420                          */
3421                         os_free(wpa_s->next_scan_freqs);
3422                         wpa_s->next_scan_freqs = freqs;
3423                 }
3424         }
3425
3426         switch (count) {
3427         case 1:
3428                 timeout = 100;
3429                 break;
3430         case 2:
3431                 timeout = 500;
3432                 break;
3433         case 3:
3434                 timeout = 1000;
3435                 break;
3436         default:
3437                 timeout = 5000;
3438         }
3439
3440         /*
3441          * TODO: if more than one possible AP is available in scan results,
3442          * could try the other ones before requesting a new scan.
3443          */
3444         wpa_supplicant_req_scan(wpa_s, timeout / 1000,
3445                                 1000 * (timeout % 1000));
3446
3447 #ifdef CONFIG_P2P
3448         if (wpa_s->global->p2p_cb_on_scan_complete && !wpa_s->global->p2p_disabled &&
3449             wpa_s->global->p2p != NULL) {
3450                 wpa_s->global->p2p_cb_on_scan_complete = 0;
3451                 if (p2p_other_scan_completed(wpa_s->global->p2p) == 1) {
3452                         wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Pending P2P operation "
3453                                 "continued after failed association");
3454                 }
3455         }
3456 #endif /* CONFIG_P2P */
3457 }
3458
3459
3460 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
3461 {
3462         return wpa_s->conf->ap_scan == 2 ||
3463                 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
3464 }
3465
3466
3467 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
3468 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
3469                                               struct wpa_ssid *ssid,
3470                                               const char *field,
3471                                               const char *value)
3472 {
3473 #ifdef IEEE8021X_EAPOL
3474         struct eap_peer_config *eap = &ssid->eap;
3475
3476         wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
3477         wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
3478                               (const u8 *) value, os_strlen(value));
3479
3480         switch (wpa_supplicant_ctrl_req_from_string(field)) {
3481         case WPA_CTRL_REQ_EAP_IDENTITY:
3482                 os_free(eap->identity);
3483                 eap->identity = (u8 *) os_strdup(value);
3484                 eap->identity_len = os_strlen(value);
3485                 eap->pending_req_identity = 0;
3486                 if (ssid == wpa_s->current_ssid)
3487                         wpa_s->reassociate = 1;
3488                 break;
3489         case WPA_CTRL_REQ_EAP_PASSWORD:
3490                 os_free(eap->password);
3491                 eap->password = (u8 *) os_strdup(value);
3492                 eap->password_len = os_strlen(value);
3493                 eap->pending_req_password = 0;
3494                 if (ssid == wpa_s->current_ssid)
3495                         wpa_s->reassociate = 1;
3496                 break;
3497         case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
3498                 os_free(eap->new_password);
3499                 eap->new_password = (u8 *) os_strdup(value);
3500                 eap->new_password_len = os_strlen(value);
3501                 eap->pending_req_new_password = 0;
3502                 if (ssid == wpa_s->current_ssid)
3503                         wpa_s->reassociate = 1;
3504                 break;
3505         case WPA_CTRL_REQ_EAP_PIN:
3506                 os_free(eap->pin);
3507                 eap->pin = os_strdup(value);
3508                 eap->pending_req_pin = 0;
3509                 if (ssid == wpa_s->current_ssid)
3510                         wpa_s->reassociate = 1;
3511                 break;
3512         case WPA_CTRL_REQ_EAP_OTP:
3513                 os_free(eap->otp);
3514                 eap->otp = (u8 *) os_strdup(value);
3515                 eap->otp_len = os_strlen(value);
3516                 os_free(eap->pending_req_otp);
3517                 eap->pending_req_otp = NULL;
3518                 eap->pending_req_otp_len = 0;
3519                 break;
3520         case WPA_CTRL_REQ_EAP_PASSPHRASE:
3521                 os_free(eap->private_key_passwd);
3522                 eap->private_key_passwd = (u8 *) os_strdup(value);
3523                 eap->pending_req_passphrase = 0;
3524                 if (ssid == wpa_s->current_ssid)
3525                         wpa_s->reassociate = 1;
3526                 break;
3527         default:
3528                 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
3529                 return -1;
3530         }
3531
3532         return 0;
3533 #else /* IEEE8021X_EAPOL */
3534         wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
3535         return -1;
3536 #endif /* IEEE8021X_EAPOL */
3537 }
3538 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
3539
3540
3541 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
3542 {
3543         int i;
3544         unsigned int drv_enc;
3545
3546         if (ssid == NULL)
3547                 return 1;
3548
3549         if (ssid->disabled)
3550                 return 1;
3551
3552         if (wpa_s && wpa_s->drv_capa_known)
3553                 drv_enc = wpa_s->drv_enc;
3554         else
3555                 drv_enc = (unsigned int) -1;
3556
3557         for (i = 0; i < NUM_WEP_KEYS; i++) {
3558                 size_t len = ssid->wep_key_len[i];
3559                 if (len == 0)
3560                         continue;
3561                 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
3562                         continue;
3563                 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
3564                         continue;
3565                 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
3566                         continue;
3567                 return 1; /* invalid WEP key */
3568         }
3569
3570         if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
3571             !ssid->ext_psk)
3572                 return 1;
3573
3574         return 0;
3575 }
3576
3577
3578 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
3579 {
3580         if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
3581                 return 1;
3582         if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
3583                 return 0;
3584         return -1;
3585 }
3586
3587
3588 void wpas_auth_failed(struct wpa_supplicant *wpa_s)
3589 {
3590         struct wpa_ssid *ssid = wpa_s->current_ssid;
3591         int dur;
3592         struct os_time now;
3593
3594         if (ssid == NULL) {
3595                 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
3596                            "SSID block");
3597                 return;
3598         }
3599
3600         if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
3601                 return;
3602
3603         ssid->auth_failures++;
3604         if (ssid->auth_failures > 50)
3605                 dur = 300;
3606         else if (ssid->auth_failures > 20)
3607                 dur = 120;
3608         else if (ssid->auth_failures > 10)
3609                 dur = 60;
3610         else if (ssid->auth_failures > 5)
3611                 dur = 30;
3612         else if (ssid->auth_failures > 1)
3613                 dur = 20;
3614         else
3615                 dur = 10;
3616
3617         os_get_time(&now);
3618         if (now.sec + dur <= ssid->disabled_until.sec)
3619                 return;
3620
3621         ssid->disabled_until.sec = now.sec + dur;
3622
3623         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
3624                 "id=%d ssid=\"%s\" auth_failures=%u duration=%d",
3625                 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
3626                 ssid->auth_failures, dur);
3627 }
3628
3629
3630 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
3631                               struct wpa_ssid *ssid, int clear_failures)
3632 {
3633         if (ssid == NULL)
3634                 return;
3635
3636         if (ssid->disabled_until.sec) {
3637                 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
3638                         "id=%d ssid=\"%s\"",
3639                         ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
3640         }
3641         ssid->disabled_until.sec = 0;
3642         ssid->disabled_until.usec = 0;
3643         if (clear_failures)
3644                 ssid->auth_failures = 0;
3645 }