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